rafcode 3.0.0 → 3.8.0

package/RAF/46-lantern-arc/plans/4-display-effort-in-compact-mode.md

@@ -0,0 +1,28 @@
+---
+effort: medium
+---
+# Task: Display effort level in compact mode task status
+
+## Objective
+Show the frontmatter effort level (low/medium/high) in the compact task status line during `raf do`.
+
+## Context
+The compact display during `raf do` shows model and fast flag in parentheses but not the effort level from the plan frontmatter. The `formatModelMetadata` function in `terminal-symbols.ts` already supports an `effort` option, and `do.ts` already passes `effort: currentModelReasoningEffort` — but `currentModelReasoningEffort` comes from `modelResolution.entry.reasoningEffort` (the model's reasoning effort parameter), NOT the frontmatter's effort field (low/medium/high). These are different concepts: frontmatter effort selects the model tier, while reasoningEffort is a runtime model parameter.
+
+## Requirements
+- Pass the frontmatter effort (low/medium/high) to the compact display
+- Show it inside parentheses: `(sonnet, medium, fast)`
+- Don't confuse it with `reasoningEffort` (model parameter)
+
+## Implementation Steps
+1. In `src/commands/do.ts`, add a variable to track the frontmatter effort level:
+   - Add `let currentEffort: string | undefined;` alongside the existing `currentModelReasoningEffort` tracking
+   - After `resolveTaskModel`, set `currentEffort = task.frontmatter?.effort;`
+2. Update the three display call sites (running ~line 827, completed ~line 1034, failed ~line 1069) to pass `effort: currentEffort` instead of `effort: currentModelReasoningEffort`
+3. Decide what to do with `currentModelReasoningEffort` — if it's not displayed anywhere else, it can be removed. If it serves another purpose, keep both.
+
+## Acceptance Criteria
+- [ ] Running task status shows effort: `● 01-task-name (sonnet, medium) 12s`
+- [ ] Effort displays correctly for low, medium, and high values
+- [ ] Tasks without effort frontmatter don't show a blank entry
+- [ ] TypeScript compiles without errors

package/RAF/46-lantern-arc/plans/5-codex-fast-mode-research.md

@@ -0,0 +1,34 @@
+---
+effort: medium
+---
+# Task: Research and wire fast mode for Codex harness
+
+## Objective
+Determine if the Codex CLI supports fast mode, and either wire it up or remove fast mode from Codex config paths entirely.
+
+## Context
+The config wizard says "RAF only applies fast mode on Claude runners" and config-docs.md states "Codex does not support fast mode." The user wants to know if this is actually true, and if Codex does support fast mode, wire it. If not, clean up by removing the fast setting from Codex-related paths rather than just warning.
+
+## Requirements
+- Research whether `codex exec` supports any fast mode flag (check `codex --help`, `codex exec --help`, or similar)
+- If supported: wire `fast: true` in `CodexRunner` similar to how `ClaudeRunner` does it
+- If NOT supported:
+  - Update `config-docs.md` to clarify fast mode is Claude-only (already says this - verify)
+  - Consider if validation should warn/strip `fast: true` from codex harness entries
+  - Update the config wizard prompt/docs to reflect this clearly
+
+## Implementation Steps
+1. Run `codex --help` and `codex exec --help` (or equivalent) to check for fast mode flags
+2. Search the codex-runner.ts for any existing fast mode references
+3. Based on findings:
+   - **If supported**: Add fast mode flag to `CodexRunner.run()` and `CodexRunner.runInteractive()` similar to `ClaudeRunner`
+   - **If NOT supported**:
+     - Verify config-docs.md accurately reflects this
+     - Add validation in `src/utils/config.ts` that warns if `fast: true` is set with codex harness
+     - Update any config wizard messaging
+
+## Acceptance Criteria
+- [ ] Fast mode either works with Codex or is explicitly unsupported with clear messaging
+- [ ] Config validation warns if user sets fast: true on a codex harness entry
+- [ ] config-docs.md is accurate
+- [ ] TypeScript compiles without errors

package/RAF/46-lantern-arc/plans/6-optimize-llm-prompts.md

@@ -0,0 +1,48 @@
+---
+effort: high
+---
+# Task: Optimize LLM prompts for clarity and conciseness
+
+## Objective
+Review and optimize the three main prompt files (planning.ts, execution.ts, amend.ts) to remove redundancy, clarify confusing statements, and reduce verbosity while preserving clarity for LLMs.
+
+## Dependencies
+1, 2
+
+## Context
+The prompts in this project are sent to LLMs and should be optimized for how LLMs process instructions. Common issues include: repeated instructions across sections, contradictory or confusing statements, unnecessary verbosity that wastes tokens without adding clarity, and instructions that could be consolidated.
+
+## Requirements
+- Review all three prompt files: `src/prompts/planning.ts`, `src/prompts/execution.ts`, `src/prompts/amend.ts`
+- Identify and remove redundant/repeated instructions
+- Clarify confusing or ambiguous statements
+- Reduce verbosity where possible without losing meaning
+- Preserve all functional requirements — don't remove instructions that change behavior
+- Keep the prompts well-structured and scannable
+
+## Implementation Steps
+1. Read `src/prompts/planning.ts` carefully and note:
+   - Repeated instructions (same thing said in multiple places)
+   - Confusing/contradictory statements
+   - Overly verbose sections that could be tightened
+2. Do the same for `src/prompts/execution.ts`
+3. Do the same for `src/prompts/amend.ts`
+4. Apply edits to each file:
+   - Consolidate repeated instructions into a single clear statement
+   - Rewrite confusing passages
+   - Trim verbose sections while preserving intent
+   - Ensure cross-references between prompts still make sense
+5. After editing, re-read each prompt end-to-end to verify coherence
+6. Note: Tasks 1 and 2 may have changed content in these files (spark alias removal, worktree cleanup from planning prompt). Work with the current state of the files.
+
+## Acceptance Criteria
+- [ ] No redundant/repeated instructions across sections within each prompt
+- [ ] No confusing or contradictory statements
+- [ ] Prompts are noticeably more concise
+- [ ] All functional requirements are preserved
+- [ ] TypeScript compiles without errors
+
+## Notes
+- This task depends on tasks 1 and 2 because those tasks modify content within the prompt files. This task should work with the already-cleaned-up versions.
+- Focus on LLM readability, not human readability. LLMs process instructions differently — clear structure and non-redundancy matter more than prose style.
+- Be conservative with the execution prompt — it's the most critical for correct task completion.

package/RAF/47-signal-trim/decisions.md

@@ -0,0 +1,13 @@
+# Project Decisions
+
+## For removing cache from status: should the cache fields be removed from UsageData/ModelTokenUsage interfaces entirely, or just hidden from display?
+Remove everything — delete cache fields from interfaces, tracking, display code, and the showCacheTokens config key.
+
+## What should the final status output look like?
+Compact single line: tokens in / out + cost (e.g., `12,345 in / 6,789 out — $0.42`).
+
+## For adding preset docs to the config wizard: what specific info should be included?
+Docs + wizard actions — add docs AND teach the wizard to run preset save/load/list/delete during the session.
+
+## What should the preset docs cover?
+Just the basics — storage path, CLI commands, name validation rules. Keep it minimal.

package/RAF/47-signal-trim/input.md

@@ -0,0 +1,2 @@
+- [ ] remove cache from 'plan do' status entirely. leave only tokens in / out and price $
+- [ ] add to config wizard docs info on how presets work so it can use it. presets path and cli api

package/RAF/47-signal-trim/plans/1-remove-cache-from-status.md

@@ -0,0 +1,73 @@
+---
+effort: medium
+---
+# Task: Remove Cache From Status Display
+
+## Objective
+Remove all cache token tracking (read/created) from the `raf do` status output, interfaces, and config — leaving only tokens in/out and cost.
+
+## Context
+The cache token display (cache read / cache created counts) adds noise to the status output without providing actionable information. The user wants a cleaner, compact output showing only input tokens, output tokens, and dollar cost.
+
+## Requirements
+- Remove `cacheReadInputTokens` and `cacheCreationInputTokens` fields from `UsageData` and `ModelTokenUsage` interfaces
+- Remove `DisplayConfig` interface and `display` field from `RafConfig` / `DEFAULT_CONFIG`
+- Remove all cache display logic from `formatTokenLine()` in `terminal-symbols.ts`
+- Remove the `showCacheTokens` option / `TokenSummaryOptions` type if it becomes empty
+- Remove cache accumulation from `token-tracker.ts` (`mergeUsageData`, `accumulateUsage`, default objects)
+- Remove cache fields from stream parsers that populate `UsageData` (`stream-renderer.ts`, `codex-stream-renderer.ts`)
+- Remove `display` validation from config validator (`src/utils/config.ts`)
+- Remove `display` section from config docs (`src/prompts/config-docs.md`)
+- Remove `display` references from all example configs in docs
+- Update `getShowCacheTokens()` call sites in `do.ts` — remove the option passing entirely
+
+## Implementation Steps
+1. **Update interfaces** (`src/types/config.ts`):
+   - Remove `cacheReadInputTokens` and `cacheCreationInputTokens` from `UsageData` interface
+   - Remove `cacheReadInputTokens` and `cacheCreationInputTokens` from `ModelTokenUsage` interface
+   - Remove `DisplayConfig` interface
+   - Remove `display` from `RafConfig` interface and `DEFAULT_CONFIG`
+
+2. **Update token tracker** (`src/utils/token-tracker.ts`):
+   - Remove all `cacheReadInputTokens` and `cacheCreationInputTokens` references from `mergeUsageData()`
+   - Remove from `accumulateUsage()` default return
+   - Remove from `getTotals()` default return
+
+3. **Update display formatting** (`src/utils/terminal-symbols.ts`):
+   - Remove cache display block from `formatTokenLine()` (lines 209-220)
+   - Remove `showCacheTokens` from `TokenSummaryOptions` — if it becomes empty, remove the type entirely
+   - Update JSDoc comments that reference cache display
+
+4. **Update stream parsers** (`src/parsers/stream-renderer.ts`, `src/parsers/codex-stream-renderer.ts`):
+   - Remove cache field population when building `UsageData` objects
+
+5. **Update do.ts** (`src/commands/do.ts`):
+   - Remove `getShowCacheTokens()` calls and the `showCacheTokens` option passing to formatters
+   - Remove any import of display config helpers
+
+6. **Update claude-runner.ts** (`src/core/claude-runner.ts`):
+   - Remove any cache-related usage data handling
+
+7. **Update config validator** (`src/utils/config.ts`):
+   - Remove `display` key validation
+   - Remove `showCacheTokens` validation
+
+8. **Update config docs** (`src/prompts/config-docs.md`):
+   - Remove the `### display` section entirely
+   - Remove `display` from all example configs (especially the "Full" example)
+   - Remove `display.showCacheTokens` from the validation rules list
+
+9. **Build and verify** — run `npm run build` to confirm no type errors remain
+
+## Acceptance Criteria
+- [ ] `UsageData` and `ModelTokenUsage` no longer contain cache fields
+- [ ] `DisplayConfig` and `display` removed from config types and defaults
+- [ ] Token summary output shows only: `Tokens: X in / Y out | Cost: $Z`
+- [ ] No references to `cacheReadInputTokens`, `cacheCreationInputTokens`, or `showCacheTokens` remain in `src/`
+- [ ] Config validator no longer accepts or validates a `display` key
+- [ ] Config docs have no mention of cache tokens or `display` section
+- [ ] Project builds cleanly (`npm run build`)
+
+## Notes
+- The cache fields originally came from Claude API responses. When removing them from the interfaces, the parsers that read API output will simply stop extracting those fields — the API may still return them but they'll be ignored.
+- There are 9 files that reference cache/display fields. All must be updated in a single coherent pass.

package/README.md

@@ -48,14 +48,14 @@ That's it! RAF will guide you through breaking down your task and then execute i
 ## Requirements
 
 - Node.js 20+
-- Claude Code CLI installed and configured (default provider)
-- Or: OpenAI Codex CLI installed and configured (for `--provider codex`)
+- Claude Code CLI installed and configured
+- Or: OpenAI Codex CLI installed and configured (set `harness` per model entry in config)
 
 ## Features
 
 - **Interactive Planning**: Interviews you to break down complex tasks into structured plans
 - **Smart Execution**: Automatic model selection, retry with escalation, and progress tracking
-- **Multi-Provider**: Use Claude Code CLI or OpenAI Codex CLI via `--provider`
+- **Multi-Harness**: Use Claude Code CLI or OpenAI Codex CLI via per-model harness config
 - **Resume & Amend**: Continue interrupted sessions or extend existing projects
 - **Git Integration**: Automatic commits, worktree isolation, and PR generation
 - **Task Dependencies**: Dependency tracking with automatic blocking on failure
@@ -71,7 +71,6 @@ Opens your `$EDITOR` to write a project description, then Claude will interview
 raf plan              # Create a new project
 raf plan my-feature   # Create with a specific name
 raf plan --amend abcdef  # Add tasks to existing project
-raf plan --worktree   # Plan in an isolated git worktree
 ```
 
 #### `--amend` vs `--resume`
@@ -85,14 +84,16 @@ raf plan --worktree   # Plan in an isolated git worktree
 Execute project tasks. Without arguments, shows a picker to select a pending project.
 
 ```bash
-raf do                # Interactive picker
+raf do                # Interactive picker (includes worktree projects)
 raf do abcdef         # Execute by project ID
 raf do my-project     # Execute by name
-raf do --worktree     # Pick and execute a worktree project
-raf do my-feature -w  # Execute in worktree (picker will ask what to do after)
 ```
 
-Note: In non-verbose mode, the completion summary reflects the tasks executed in that run (the remaining tasks at start), so the elapsed time maps to those tasks.
+Note: In non-verbose mode, task lines show the resolved model in the existing parentheses slot and append reasoning effort and `fast` when configured, for example `● 01-auth-login (sonnet, low, fast) 12s`. Fast mode is Claude-only; if set on a Codex entry, RAF warns and ignores it.
+
+Note: The completion summary reflects the tasks executed in that run (the remaining tasks at start), so the elapsed time maps to those tasks.
+
+Note: Post-run token summaries now show exact input/output token counts for both Claude and Codex runs. Dollar cost is shown only when the provider reports an exact value, so current Codex summaries are token-only.
 
 ### `raf status`
 
@@ -105,12 +106,20 @@ raf status abcdef     # Show details for a project (shows both main and worktree
 
 ### `raf config`
 
-View and edit RAF configuration through an interactive Claude session. Configuration is stored at `~/.raf/raf.config.json`. All settings are optional — only set what you want to change.
+Read, write, reset, and edit RAF configuration. Configuration is stored at `~/.raf/raf.config.json`. All settings are optional — only set what you want to change.
 
 ```bash
-raf config               # Interactive config editor
-raf config "use haiku for name generation"  # Start with a specific request
-raf config --reset       # Reset config to defaults
+raf config                         # Show config subcommands
+raf config get                     # Print resolved config
+raf config get models.execute      # Print one resolved value
+raf config set timeout 45          # Write a value
+raf config reset                   # Reset config to defaults
+raf config wizard                  # Interactive config editor
+raf config wizard "use haiku for name generation"  # Start with a specific request
+raf config preset save claude-setup    # Save current config as "claude-setup"
+raf config preset load claude-setup    # Restore "claude-setup" (overwrites current config)
+raf config preset list                 # Show all saved presets
+raf config preset delete claude-setup  # Remove a preset
 ```
 
 **Precedence**: CLI flags > config file > built-in defaults
@@ -119,51 +128,30 @@ Example `~/.raf/raf.config.json`:
 
 ```json
 {
-  "provider": "claude",
   "models": {
-    "execute": "sonnet",
-    "nameGeneration": "haiku"
+    "execute": { "model": "sonnet", "harness": "claude" },
+    "nameGeneration": { "model": "haiku", "harness": "claude" }
   },
   "worktree": true,
   "timeout": 45
 }
 ```
 
-Run `raf config` without arguments and ask what's available — the session has full knowledge of every configurable option.
-
-## Provider Configuration
-
-RAF supports multiple LLM providers. The default is `claude` (Claude Code CLI). To use OpenAI Codex CLI, set `provider: "codex"` in your config or pass `--provider codex` on the command line.
+Run `raf config wizard` and ask what's available — the session has full knowledge of every configurable option.
 
-```bash
-raf plan --provider codex   # Plan using Codex
-raf do --provider codex     # Execute using Codex
-```
+## Harness Configuration
 
-### Model spec format
-
-Models can be specified as plain aliases or with a provider prefix (`<provider>/<alias>`):
-
-```bash
-raf do -m opus              # Claude: resolves to claude-opus-4-6
-raf do -m claude/opus       # Same as above, explicit prefix
-raf do -m codex/gpt54       # Codex: resolves to gpt-5.4
-raf do -m codex/gpt-5.4     # Codex: raw model ID
-```
-
-### Codex config
+RAF supports multiple LLM harnesses per scenario. Each model entry in `models` and `effortMapping` specifies its own `harness`, so you can mix Claude and Codex freely:
 
 ```json
 {
-  "provider": "codex",
-  "codexModels": {
-    "execute": "codex",
-    "plan": "gpt54"
+  "models": {
+    "plan": { "model": "opus", "harness": "claude" },
+    "execute": { "model": "gpt-5.4", "harness": "codex" }
   },
-  "codexEffortMapping": {
-    "low": "spark",
-    "medium": "codex",
-    "high": "gpt54"
+  "effortMapping": {
+    "low": { "model": "sonnet", "harness": "claude" },
+    "high": { "model": "gpt-5.4", "harness": "codex" }
   }
 }
 ```
@@ -171,6 +159,7 @@ raf do -m codex/gpt-5.4     # Codex: raw model ID
 **Codex limitations:**
 - `--resume` is not supported (Codex CLI has no session resume)
 - System prompt is prepended to the user message rather than passed separately
+- Post-run summaries currently include exact token counts but omit USD cost because Codex CLI does not provide an exact per-run price
 
 ## Status Symbols
 
@@ -205,11 +194,11 @@ Worktree mode runs planning and execution in an isolated git worktree, keeping y
 ### Basic workflow
 
 ```bash
-# Plan in a worktree (creates branch and worktree directory)
-raf plan my-feature --worktree
+# Plan in a worktree (enabled via config: "worktree": true)
+raf plan my-feature
 
-# Execute tasks in the worktree
-raf do my-feature --worktree
+# Execute tasks in the worktree (auto-detected, no flag needed)
+raf do my-feature
 ```
 
 ### Post-execution picker
@@ -236,12 +225,12 @@ If `gh` is missing or unauthenticated, the option falls back to "Leave branch" w
 
 ### How it works
 
-- `--worktree` creates a git worktree at `~/.raf/worktrees/<repo>/<project>/` with a new branch named after the project folder (e.g., `abcdef-my-feature`)
+- When `worktree: true` is set in config, `raf plan` creates a git worktree at `~/.raf/worktrees/<repo>/<project>/` with a new branch named after the project folder (e.g., `abcdef-my-feature`)
 - All planning artifacts, code changes, and commits happen in the worktree branch
+- `raf do` auto-detects whether a project lives in a worktree — no flag needed
 - After successful post-actions (merge, PR, or leave), the worktree directory is cleaned up automatically — the git branch is preserved
 - On merge conflicts, the merge is aborted and you get instructions for manual resolution
 - If tasks fail, the worktree is kept for inspection
-- Use `--no-worktree` to disable worktree mode for a single invocation (useful when `worktree: true` is set in config)
 
 ## Command Reference
 
@@ -251,10 +240,6 @@ If `gh` is missing or unauthenticated, the option falls back to "Leave branch" w
 |--------|-------------|
 | `--amend <id>` | Add tasks to existing project |
 | `-y, --auto` | Skip permission prompts (runs in dangerous mode) |
-| `-p, --provider <name>` | LLM provider to use (`claude`, `codex`) |
-| `-m, --model <name>` | Model to use (e.g. `opus`, `codex/gpt54`) |
-| `-w, --worktree` | Create a git worktree for isolated planning |
-| `--no-worktree` | Disable worktree mode (overrides config) |
 
 ### `raf do [project]`
 
@@ -263,21 +248,23 @@ If `gh` is missing or unauthenticated, the option falls back to "Leave branch" w
 | `-t, --timeout <min>` | Timeout per task (default: 60) |
 | `-f, --force` | Re-run all tasks regardless of status |
 | `-d, --debug` | Save all logs and show debug output |
-| `-p, --provider <name>` | LLM provider to use (`claude`, `codex`) |
-| `-m, --model <name>` | Model to use (e.g. `sonnet`, `codex/gpt54`) |
-| `--sonnet` | Shorthand for `--model sonnet` |
-| `-w, --worktree` | Execute tasks in a git worktree |
-| `--no-worktree` | Disable worktree mode (overrides config) |
 
 Alias: `raf act`
 
 > **Note:** `raf do` and `raf plan -y` run the CLI with skip-permissions flags for fully automated execution without interactive prompts.
 
-### `raf config [prompt]`
+### `raf config`
 
-| Option | Description |
-|--------|-------------|
-| `--reset` | Reset config file to defaults |
+| Subcommand | Description |
+|------------|-------------|
+| `get [key]` | Show the resolved config or one resolved dot-notation value |
+| `set <key> <value>` | Write a config value using a dot-notation key |
+| `reset` | Delete the config file and restore defaults after confirmation |
+| `wizard [prompt]` | Launch the interactive config editor |
+| `preset save <name>` | Save current config as a named preset |
+| `preset load <name>` | Load a preset (overwrites current config) |
+| `preset list` | List all saved presets |
+| `preset delete <name>` | Delete a preset |
 
 ### `raf status [identifier]`
 

package/dist/commands/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4UpC,wBAAgB,mBAAmB,IAAI,OAAO,CAsC7C"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmUpC,wBAAgB,mBAAmB,IAAI,OAAO,CA4C7C"}

package/dist/commands/config.js

@@ -6,8 +6,9 @@ import { Command } from 'commander';
 import { createRunner } from '../core/runner-factory.js';
 import { shutdownHandler } from '../core/shutdown-handler.js';
 import { logger } from '../utils/logger.js';
-import { getConfigPath, getModel, getModelShortName, validateConfig, ConfigValidationError, resetConfigCache, resolveConfig, saveConfig, } from '../utils/config.js';
+import { getConfigPath, formatModelDisplay, getModel, validateConfig, collectConfigValidationWarnings, ConfigValidationError, resetConfigCache, resolveConfig, saveConfig, } from '../utils/config.js';
 import { DEFAULT_CONFIG } from '../types/config.js';
+import { createPresetCommand } from './preset.js';
 /**
  * Load the config documentation markdown from src/prompts/config-docs.md.
  * Resolved relative to this file's location in the dist/ tree.
@@ -72,11 +73,11 @@ function postSessionValidation(configPath) {
     catch (error) {
         if (error instanceof ConfigValidationError) {
             logger.warn(`Config validation warning: ${error.message}`);
-            logger.warn('The file was not deleted — you can fix it manually or run `raf config` again.');
+            logger.warn('The file was not deleted — you can fix it manually or run `raf config wizard` again.');
         }
         else if (error instanceof SyntaxError) {
             logger.warn('Config file contains invalid JSON.');
-            logger.warn('The file was not deleted — you can fix it manually or run `raf config` again.');
+            logger.warn('The file was not deleted — you can fix it manually or run `raf config wizard` again.');
         }
         else {
             logger.warn(`Could not validate config: ${error}`);
@@ -205,16 +206,14 @@ function formatValue(value) {
 }
 // ---- Config get/set handlers ----
 /**
- * Handle --get flag: print config value(s).
+ * Print config value(s).
  */
 function handleGet(key) {
     const config = resolveConfig();
-    if (key === true) {
-        // No key specified: print full config
+    if (key === undefined) {
         console.log(JSON.stringify(config, null, 2));
         return;
     }
-    // Specific key requested
     const value = getNestedValue(config, key);
     if (value === undefined) {
         logger.error(`Config key not found: ${key}`);
@@ -223,14 +222,9 @@ function handleGet(key) {
     console.log(formatValue(value));
 }
 /**
- * Handle --set flag: update config file with a new value.
+ * Update config file with a new value.
  */
-function handleSet(args) {
-    if (args.length !== 2) {
-        logger.error('--set requires exactly 2 arguments: key and value');
-        process.exit(1);
-    }
-    const [key, rawValue] = args;
+function handleSet(key, rawValue) {
     const value = parseValue(rawValue);
     const configPath = getConfigPath();
     // Read current user config (or start with empty)
@@ -265,7 +259,10 @@ function handleSet(args) {
     }
     // Validate the resulting config
     try {
-        validateConfig(userConfig);
+        const validated = validateConfig(userConfig);
+        for (const warning of collectConfigValidationWarnings(validated)) {
+            logger.warn(`Config validation warning: ${warning}`);
+        }
     }
     catch (error) {
         if (error instanceof ConfigValidationError) {
@@ -289,36 +286,37 @@ function handleSet(args) {
 }
 export function createConfigCommand() {
     const command = new Command('config')
-        .description('View and edit RAF configuration interactively')
+        .description('Manage RAF configuration with get, set, reset, wizard, and preset subcommands')
+        .action(function () {
+        this.outputHelp();
+    });
+    command
+        .addCommand(new Command('get')
+        .description('Print the resolved config or one resolved dot-notation value')
+        .argument('[key]', 'Optional dot-notation key to read')
+        .action((key) => {
+        handleGet(key);
+    }))
+        .addCommand(new Command('set')
+        .description('Write a config value using a dot-notation key')
+        .argument('<key>', 'Dot-notation key to write')
+        .argument('<value>', 'Value to write; parsed as JSON when possible')
+        .action((key, value) => {
+        handleSet(key, value);
+    }))
+        .addCommand(new Command('reset')
+        .description('Delete the config file and restore all defaults')
+        .action(async () => {
+        await handleReset();
+    }))
+        .addCommand(new Command('wizard')
+        .description('Launch the interactive config editor session')
         .argument('[prompt...]', 'Optional initial prompt for the config session')
-        .option('--reset', 'Delete config file and restore all defaults')
-        .option('--get [key]', 'Show config value (all config if no key, or specific dot-notation key)')
-        .option('--set <items...>', 'Set a config value using dot-notation key and value')
-        .action(async (promptParts, options) => {
-        // --reset takes precedence
-        if (options.reset) {
-            await handleReset();
-            return;
-        }
-        // --get and --set are mutually exclusive
-        if (options.get !== undefined && options.set !== undefined) {
-            logger.error('Cannot use --get and --set together');
-            process.exit(1);
-        }
-        // Handle --get
-        if (options.get !== undefined) {
-            handleGet(options.get);
-            return;
-        }
-        // Handle --set
-        if (options.set !== undefined) {
-            handleSet(options.set);
-            return;
-        }
-        // Default: run interactive session
+        .action(async (promptParts) => {
         const initialPrompt = promptParts.length > 0 ? promptParts.join(' ') : undefined;
         await runConfigSession(initialPrompt);
-    });
+    }))
+        .addCommand(createPresetCommand());
     return command;
 }
 async function handleReset() {
@@ -338,23 +336,23 @@ async function handleReset() {
 async function runConfigSession(initialPrompt) {
     const configPath = getConfigPath();
     // Try to load config, but fall back to defaults if it's broken
-    // This allows raf config to be used to fix a broken config file
-    let model;
+    // This allows raf config wizard to be used to fix a broken config file
+    let modelEntry;
     let configError = null;
     try {
-        model = getModel('config');
+        modelEntry = getModel('config');
     }
     catch (error) {
         // Config file has errors - fall back to defaults so the session can launch
         configError = error instanceof Error ? error : new Error(String(error));
-        model = DEFAULT_CONFIG.models.config;
+        modelEntry = DEFAULT_CONFIG.models.config;
         // Clear the cached config so subsequent calls don't use the broken cache
         resetConfigCache();
     }
     // Warn user if config has errors, before starting the session
     if (configError) {
         logger.warn(`Config file has errors, using defaults: ${configError.message}`);
-        logger.warn('Fix the config in this session or run `raf config --reset` to start fresh.');
+        logger.warn('Fix the config in this session or run `raf config reset` to start fresh.');
         logger.newline();
     }
     // Load config docs
@@ -373,10 +371,10 @@ async function runConfigSession(initialPrompt) {
     const userMessage = initialPrompt
         ?? 'Show me my current config and help me make changes.';
     // Set up runner
-    const claudeRunner = createRunner({ model });
+    const claudeRunner = createRunner({ model: modelEntry.model, harness: modelEntry.harness, reasoningEffort: modelEntry.reasoningEffort, fast: modelEntry.fast });
     shutdownHandler.init();
     shutdownHandler.registerClaudeRunner(claudeRunner);
-    const configModel = getModelShortName(model);
+    const configModel = formatModelDisplay(modelEntry.model);
     logger.info(`Starting config session with ${configModel}...`);
     logger.newline();
     try {