@sentry/warden 0.21.0 → 0.23.0

package/dist/cli/main.js

@@ -1,18 +1,21 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { config as dotenvConfig } from 'dotenv';
 import { Sentry, flushSentry, setGlobalAttributes, emitRunMetric, getTraceId } from '../sentry.js';
-import { loadWardenConfig, resolveSkillConfigs } from '../config/loader.js';
+import { emptyToUndefined, loadWardenConfig, resolveSkillConfigs } from '../config/loader.js';
 import { verifyAuth } from '../sdk/runner.js';
-import { resolveSkillAsync } from '../skills/loader.js';
+import { mapExtractionErrorCode } from '../sdk/errors.js';
+import { mergeAuxiliaryUsage } from '../sdk/usage.js';
+import { resolveSkillAsync, SkillLoaderError } from '../skills/loader.js';
 import { matchTrigger, filterContextByPaths, shouldFail, countFindingsAtOrAbove } from '../triggers/matcher.js';
 import { filterFindings } from '../types/index.js';
 import { DEFAULT_CONCURRENCY, getAnthropicApiKey } from '../utils/index.js';
-import { parseCliArgs, showHelp, showVersion, classifyTargets } from './args.js';
+import { parseCliArgs, showVersion, classifyTargets } from './args.js';
+import { showHelp } from './help.js';
 import { buildLocalEventContext, buildFileEventContext } from './context.js';
-import { getRepoRoot, getHeadSha, refExists, hasUncommittedChanges } from './git.js';
+import { getRepoRoot, getHeadSha, refExists, getDefaultBranch } from './git.js';
 import { renderTerminalReport, filterReports } from './terminal.js';
-import { Reporter, detectOutputMode, parseVerbosity, Verbosity, runSkillTasks, runSkillTasksWithInk, pluralize, MODEL_DEFAULT_SENTINEL, writeJsonlContent, renderJsonlString, renderJsonlSkillLine, renderJsonlSummaryLine, initJsonlFile, appendJsonlLine, getRepoLogPath, generateRunId, } from './output/index.js';
+import { Reporter, detectOutputMode, parseVerbosity, Verbosity, runSkillTasks, runSkillTasksWithInk, pluralize, MODEL_DEFAULT_SENTINEL, writeJsonlContent, renderJsonlString, renderJsonlChunkLine, renderJsonlChunkRecords, initJsonlFile, appendJsonlLine, getRepoLogPath, generateRunId, } from './output/index.js';
 import { cleanupArtifacts } from './log-cleanup.js';
 import { collectFixableFindings, applyAllFixes, runInteractiveFixFlow, renderFixSummary, } from './fix.js';
 import { UserAbortError } from './input.js';
@@ -21,6 +24,8 @@ import { runAdd } from './commands/add.js';
 import { runSetupApp } from './commands/setup-app.js';
 import { runSync } from './commands/sync.js';
 import { runRuns } from './commands/runs.js';
+import { runBuild, runImprove } from './commands/build.js';
+import { generatedSkillDefinitionRootExists, resolveGeneratedSkillTarget, } from '../skill-builder/definition.js';
 /**
  * Global abort controller for graceful shutdown on SIGINT.
  * Used to cancel in-progress SDK queries.
@@ -52,22 +57,31 @@ function loadEnvFiles(dir) {
         dotenvConfig({ path: envLocalPath, override: true, quiet: true });
     }
 }
-/**
- * Create a Reporter instance from CLI options.
- */
 function createReporter(options) {
     const detected = detectOutputMode(options.color);
     const outputMode = options.log ? { ...detected, isTTY: false } : detected;
     const verbosity = parseVerbosity(options.quiet, options.verbose, options.debug);
     return new Reporter(outputMode, verbosity);
 }
-/**
- * Resolve the config file path based on CLI options and repo root.
- */
+/** Resolve the directory Warden should treat as the invocation root. */
+export function resolveInvocationCwd(baseCwd, cliCwd) {
+    return cliCwd ? resolve(baseCwd, cliCwd) : baseCwd;
+}
 function resolveConfigPath(options, repoPath) {
     const cwd = process.cwd();
     return options.config ? resolve(cwd, options.config) : resolve(repoPath, 'warden.toml');
 }
+function resolveLocalReviewBase(configDefaultBranch, repoPath) {
+    const defaultBranch = configDefaultBranch ?? getDefaultBranch(repoPath);
+    if (defaultBranch.includes('/')) {
+        return { defaultBranch, base: defaultBranch };
+    }
+    const remoteTrackingRef = `origin/${defaultBranch}`;
+    return {
+        defaultBranch,
+        base: refExists(remoteTrackingRef, repoPath) ? remoteTrackingRef : defaultBranch,
+    };
+}
 /**
  * Emit a minimal JSONL log (summary-only, 0 findings) for early-exit paths.
  *
@@ -146,17 +160,139 @@ function initializeRunLog(args) {
         }
     }
     const paths = [];
+    const seenPaths = new Set();
+    const addPath = (path) => {
+        const key = resolve(process.cwd(), path);
+        if (seenPaths.has(key))
+            return;
+        seenPaths.add(key);
+        paths.push(path);
+    };
     if (primaryLogWritten)
-        paths.push(primaryLogPath);
+        addPath(primaryLogPath);
     if (resolvedOutputPath)
-        paths.push(resolvedOutputPath);
-    return { paths, primaryLogPath, primaryLogWritten, outputPath: resolvedOutputPath, startTime, baseRun };
+        addPath(resolvedOutputPath);
+    return { paths, primaryLogPath, primaryLogWritten, outputPath: resolvedOutputPath, startTime, baseRun, chunks: [] };
 }
-function appendSkillToRunLog(log, report) {
+function appendChunkToRunLog(log, skillName, chunk) {
     if (log.paths.length === 0)
         return;
-    const run = { ...log.baseRun, durationMs: Date.now() - log.startTime };
-    const line = renderJsonlSkillLine(report, run);
+    const auxiliaryUsage = chunk.auxiliaryUsage?.reduce((acc, entry) => mergeAuxiliaryUsage(acc, { [entry.agent]: entry.usage }), undefined);
+    const error = chunk.failed
+        ? {
+            code: chunk.failureCode ?? 'unknown',
+            message: chunk.failureMessage ?? 'unknown error',
+            timestamp: new Date().toISOString(),
+        }
+        : chunk.extractionFailed
+            ? {
+                code: mapExtractionErrorCode(chunk.extractionError),
+                message: chunk.extractionError ?? 'unknown extraction error',
+                timestamp: new Date().toISOString(),
+            }
+            : undefined;
+    const record = {
+        schemaVersion: 1,
+        run: { ...log.baseRun, durationMs: Date.now() - log.startTime },
+        skill: skillName,
+        model: chunk.model,
+        chunk: {
+            file: chunk.filename,
+            index: chunk.index,
+            total: chunk.total,
+            lineRange: chunk.lineRange,
+        },
+        status: error ? 'error' : 'ok',
+        findings: chunk.findings,
+        usage: chunk.usage,
+        durationMs: chunk.durationMs,
+        auxiliaryUsage,
+        error,
+    };
+    let line;
+    try {
+        line = renderJsonlChunkLine(record);
+    }
+    catch {
+        return;
+    }
+    log.chunks.push(record);
+    for (const p of log.paths) {
+        try {
+            appendJsonlLine(p, line);
+        }
+        catch { /* best-effort */ }
+    }
+}
+function buildReportChunkRecord(log, report, runDurationMs, index = 1, total = 1, error) {
+    const reportError = report.error ?? error;
+    return {
+        schemaVersion: 1,
+        run: { ...log.baseRun, durationMs: runDurationMs },
+        skill: report.skill,
+        model: report.model,
+        chunk: {
+            file: report.skippedFiles?.[0]?.filename ?? '',
+            index,
+            total,
+            lineRange: '',
+        },
+        status: reportError ? 'error' : report.skippedFiles?.length ? 'skipped' : 'ok',
+        findings: report.findings,
+        usage: report.usage,
+        durationMs: report.durationMs ?? runDurationMs,
+        auxiliaryUsage: report.auxiliaryUsage,
+        error: reportError,
+        skippedFiles: report.skippedFiles,
+    };
+}
+function buildRunErrorChunkRecord(log, runDurationMs, error) {
+    return {
+        schemaVersion: 1,
+        run: { ...log.baseRun, durationMs: runDurationMs },
+        skill: 'run',
+        chunk: {
+            file: '',
+            index: 1,
+            total: 1,
+            lineRange: '',
+        },
+        status: 'error',
+        findings: [],
+        durationMs: runDurationMs,
+        error,
+    };
+}
+function hasReportRecord(log, report) {
+    return log.chunks.some((chunk) => {
+        if (chunk.skill !== report.skill)
+            return false;
+        if (report.error) {
+            return chunk.error?.code === report.error.code && chunk.error.message === report.error.message;
+        }
+        if (report.skippedFiles?.length) {
+            return (chunk.skippedFiles?.length ?? 0) > 0;
+        }
+        return true;
+    });
+}
+function shouldStreamReportRecord(log, report) {
+    if (hasReportRecord(log, report))
+        return false;
+    return Boolean(report.error || report.skippedFiles?.length || !log.chunks.some((chunk) => chunk.skill === report.skill));
+}
+function appendReportToRunLog(log, report) {
+    if (!shouldStreamReportRecord(log, report))
+        return;
+    const record = buildReportChunkRecord(log, report, Date.now() - log.startTime);
+    let line;
+    try {
+        line = renderJsonlChunkLine(record);
+    }
+    catch {
+        return;
+    }
+    log.chunks.push(record);
     for (const p of log.paths) {
         try {
             appendJsonlLine(p, line);
@@ -164,26 +300,198 @@ function appendSkillToRunLog(log, report) {
         catch { /* best-effort */ }
     }
 }
+function lineRangeIncludes(lineRange, line) {
+    if (!lineRange)
+        return false;
+    const [startText, endText] = lineRange.split('-');
+    const start = Number(startText);
+    const end = endText ? Number(endText) : start;
+    return Number.isFinite(start) && Number.isFinite(end) && line >= start && line <= end;
+}
+function findChunkForFinding(chunks, skill, finding) {
+    const sameSkill = chunks.filter((chunk) => chunk.skill === skill && chunk.chunk.file);
+    const location = finding.location;
+    if (!location)
+        return sameSkill[0];
+    return sameSkill.find((chunk) => chunk.chunk.file === location.path && lineRangeIncludes(chunk.chunk.lineRange, location.startLine)) ?? sameSkill.find((chunk) => chunk.chunk.file === location.path) ?? sameSkill[0];
+}
+function buildFinalChunkRecords(log, reports, totalDurationMs, error) {
+    const finalRun = { ...log.baseRun, durationMs: totalDurationMs };
+    if (log.chunks.length === 0) {
+        if (reports.length === 0 && error) {
+            return [buildRunErrorChunkRecord(log, totalDurationMs, error)];
+        }
+        return reports.map((report) => buildReportChunkRecord(log, report, totalDurationMs, undefined, undefined, error));
+    }
+    const findingsByChunk = new Map();
+    for (const report of reports) {
+        for (const finding of report.findings) {
+            const chunk = findChunkForFinding(log.chunks, report.skill, finding);
+            if (!chunk)
+                continue;
+            const findings = findingsByChunk.get(chunk) ?? [];
+            findings.push(finding);
+            findingsByChunk.set(chunk, findings);
+        }
+    }
+    const chunkRecords = log.chunks.map((chunk) => ({
+        ...chunk,
+        run: { ...finalRun },
+        findings: findingsByChunk.get(chunk) ?? [],
+    }));
+    const finalLog = { ...log, chunks: chunkRecords };
+    const missingReports = reports.filter((report) => shouldStreamReportRecord(finalLog, report));
+    return [
+        ...chunkRecords,
+        ...missingReports.map((report) => buildReportChunkRecord(log, report, totalDurationMs, undefined, undefined, error)),
+    ];
+}
 /**
- * Append the run-final summary record. Returns the set of paths that
+ * Rewrite the run log with final chunk records. Returns the set of paths that
  * accepted the write, so the caller can decide whether to claim
- * "wrote JSONL output to X" (only true when the summary actually landed).
+ * "wrote JSONL output to X" (only true when the final log actually landed).
  */
 function finalizeRunLog(log, reports, totalDurationMs, error) {
     const wrote = new Set();
     if (log.paths.length === 0)
         return wrote;
-    const run = { ...log.baseRun, durationMs: totalDurationMs };
-    const line = renderJsonlSummaryLine(reports, run, error);
+    let content;
+    try {
+        const records = buildFinalChunkRecords(log, reports, totalDurationMs, error);
+        content = renderJsonlChunkRecords(records);
+    }
+    catch {
+        return wrote;
+    }
     for (const p of log.paths) {
+        const targetPath = resolve(process.cwd(), p);
+        const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+        const tempDonePath = `${tempPath}.done`;
         try {
-            appendJsonlLine(p, line);
+            writeJsonlContent(tempPath, content);
+            writeFileSync(tempDonePath, '');
+            renameSync(tempPath, targetPath);
+            renameSync(tempDonePath, `${targetPath}.done`);
             wrote.add(p);
         }
-        catch { /* best-effort */ }
+        catch {
+            try {
+                unlinkSync(tempPath);
+            }
+            catch { /* ignore */ }
+            try {
+                unlinkSync(tempDonePath);
+            }
+            catch { /* ignore */ }
+            // best-effort
+        }
     }
     return wrote;
 }
+/** Apply per-skill runner overrides on top of the shared execution defaults. */
+export function mergeSkillRunnerOptions(base, overrides) {
+    const merged = { ...base };
+    if (overrides.model !== undefined)
+        merged.model = overrides.model;
+    if (overrides.maxTurns !== undefined)
+        merged.maxTurns = overrides.maxTurns;
+    if (overrides.runtime !== undefined)
+        merged.runtime = overrides.runtime;
+    if (overrides.auxiliaryModel !== undefined)
+        merged.auxiliaryModel = overrides.auxiliaryModel;
+    if (overrides.synthesisModel !== undefined)
+        merged.synthesisModel = overrides.synthesisModel;
+    if (overrides.auxiliaryMaxRetries !== undefined) {
+        merged.auxiliaryMaxRetries = overrides.auxiliaryMaxRetries;
+    }
+    if (overrides.verifyFindings !== undefined)
+        merged.verifyFindings = overrides.verifyFindings;
+    return merged;
+}
+function renderSkillRunHeader(args) {
+    const { reporter, skill, repoPath, runtimeName, model } = args;
+    const source = skill.rootDir && repoPath && skill.rootDir.startsWith(repoPath)
+        ? skill.rootDir.slice(repoPath.length + 1)
+        : skill.rootDir;
+    reporter.blank();
+    reporter.text(`  Skill    ${skill.name}`);
+    if (source) {
+        reporter.text(`  Source   ${source}`);
+    }
+    reporter.text(`  Model    ${model ?? 'default'} [${runtimeName}]`);
+    reporter.blank();
+}
+async function createDirectSkillTask(args) {
+    const { spec, repoPath, options, reporter, renderHeader } = args;
+    let skill;
+    try {
+        skill = await resolveSkillAsync(spec.skill, repoPath, {
+            remote: spec.remote,
+            offline: options.offline,
+        });
+    }
+    catch (error) {
+        if (error instanceof SkillLoaderError &&
+            repoPath &&
+            generatedSkillDefinitionRootExists(resolveGeneratedSkillTarget(repoPath, spec.skill).rootDir)) {
+            throw new Error(`Generated skill ${spec.skill} is missing generated artifacts. Run "warden build ${spec.skill}" first.`);
+        }
+        throw error;
+    }
+    if (renderHeader && !options.json) {
+        renderSkillRunHeader({
+            reporter,
+            skill,
+            repoPath,
+            runtimeName: spec.runnerOptions.runtime ?? 'claude',
+            model: spec.runnerOptions.model,
+        });
+    }
+    return {
+        name: spec.name,
+        displayName: spec.displayName,
+        failOn: spec.failOn,
+        minConfidence: spec.minConfidence,
+        resolveSkill: async () => skill,
+        context: spec.context,
+        runnerOptions: spec.runnerOptions,
+    };
+}
+/** Expand configured skills into runnable direct tasks. */
+export async function createSkillTasks(args) {
+    const tasks = [];
+    const singleDirectSkill = args.specs.length === 1;
+    for (const spec of args.specs) {
+        tasks.push(await createDirectSkillTask({
+            spec,
+            repoPath: args.repoPath,
+            options: args.options,
+            reporter: args.reporter,
+            renderHeader: singleDirectSkill,
+        }));
+    }
+    return tasks;
+}
+/** Resolve the default analysis model from config, CLI overrides, or environment. */
+export function resolveCliDefaultModel(config, cliModel) {
+    return (emptyToUndefined(config?.defaults?.agent?.model) ??
+        emptyToUndefined(config?.defaults?.model) ??
+        emptyToUndefined(cliModel) ??
+        emptyToUndefined(process.env['WARDEN_MODEL']));
+}
+/** Resolve the default auxiliary model used for helper and repair passes. */
+export function resolveCliDefaultAuxiliaryModel(config) {
+    return emptyToUndefined(config?.defaults?.auxiliary?.model);
+}
+/** Resolve the default synthesis model, falling back to the auxiliary lane when unset. */
+export function resolveCliDefaultSynthesisModel(config) {
+    return (emptyToUndefined(config?.defaults?.synthesis?.model) ??
+        resolveCliDefaultAuxiliaryModel(config));
+}
+/** Resolve the model label recorded in JSONL output, including the default sentinel. */
+export function resolveCliLogModel(config, cliModel) {
+    return resolveCliDefaultModel(config, cliModel) ?? MODEL_DEFAULT_SENTINEL;
+}
 /**
  * Process skill task results into reports and check for failures.
  * Exported for testing; callers inside main.ts use it directly.
@@ -216,9 +524,6 @@ export function processTaskResults(results, reportOn, minConfidence) {
     const filteredReports = filterReports(reports, reportOn, minConfidence);
     return { reports, filteredReports, hasFailure, failureReasons };
 }
-/**
- * Output results and handle fixes. Returns exit code.
- */
 async function outputResultsAndHandleFixes(processed, options, reporter, runLog, totalDuration, failFastAborted) {
     const { reports, filteredReports, hasFailure, failureReasons } = processed;
     const traceId = runLog.baseRun.traceId;
@@ -247,8 +552,7 @@ async function outputResultsAndHandleFixes(processed, options, reporter, runLog,
         // Prefer reading the on-disk log (per-skill durationMs is a snapshot).
         // Only read it back if finalize actually landed the summary there;
         // a half-written file should fall through to the in-memory render.
-        // The fallback uses the run total for every record — structurally
-        // valid but not byte-identical to the file.
+        // The fallback renders the same chunk-record shape in memory.
         let jsonlContent;
         if (finalizedPaths.has(runLog.primaryLogPath)) {
             try {
@@ -257,14 +561,13 @@ async function outputResultsAndHandleFixes(processed, options, reporter, runLog,
             catch { /* fall through */ }
         }
         if (!jsonlContent) {
-            jsonlContent = renderJsonlString(reports, totalDuration, {
-                runId: runLog.baseRun.runId,
-                traceId,
-                timestamp: new Date(runLog.baseRun.timestamp),
-                model: runLog.baseRun.model,
-                headSha: runLog.baseRun.headSha,
-                cwd: runLog.baseRun.cwd,
-            });
+            try {
+                jsonlContent = renderJsonlChunkRecords(buildFinalChunkRecords(runLog, reports, totalDuration));
+            }
+            catch (err) {
+                reporter.error(`Failed to render JSONL output: ${err instanceof Error ? err.message : String(err)}`);
+                return 1;
+            }
         }
         process.stdout.write(jsonlContent);
     }
@@ -310,12 +613,8 @@ async function outputResultsAndHandleFixes(processed, options, reporter, runLog,
     }
     return 0;
 }
-/**
- * Run skills on a context and output results.
- * If skillName is provided, runs only that skill.
- * Otherwise, runs skills from matched triggers in warden.toml.
- */
-async function runSkills(context, options, reporter) {
+/** Run one or more skills against an already constructed review context. */
+export async function runSkills(context, options, reporter) {
     const cwd = process.cwd();
     const startTime = Date.now();
     // Get API key (optional - SDK can use Claude Code subscription auth)
@@ -357,6 +656,9 @@ async function runSkills(context, options, reporter) {
     const config = configPath && existsSync(configPath)
         ? loadWardenConfig(dirname(configPath))
         : null;
+    const defaultModel = resolveCliDefaultModel(config, options.model);
+    const defaultAuxiliaryModel = resolveCliDefaultAuxiliaryModel(config);
+    const defaultSynthesisModel = resolveCliDefaultSynthesisModel(config);
     // Determine which triggers/skills to run
     let skillsToRun;
     if (options.skill) {
@@ -369,7 +671,20 @@ async function runSkills(context, options, reporter) {
         const fallbackFilters = defaultIgnorePaths?.length
             ? { ignorePaths: defaultIgnorePaths }
             : {};
-        skillsToRun = [{ skill: options.skill, remote: match?.remote, filters: match?.filters ?? fallbackFilters }];
+        skillsToRun = [{
+                skill: options.skill,
+                remote: match?.remote,
+                filters: match?.filters ?? fallbackFilters,
+                model: match?.model ?? defaultModel,
+                maxTurns: match?.maxTurns ?? config?.defaults?.agent?.maxTurns ?? config?.defaults?.maxTurns,
+                runtime: match?.runtime ?? config?.defaults?.runtime ?? 'claude',
+                auxiliaryModel: match?.auxiliaryModel ?? defaultAuxiliaryModel,
+                synthesisModel: match?.synthesisModel ?? defaultSynthesisModel,
+                auxiliaryMaxRetries: match?.auxiliaryMaxRetries ??
+                    config?.defaults?.auxiliary?.maxRetries ??
+                    config?.defaults?.auxiliaryMaxRetries,
+                verifyFindings: match?.verifyFindings ?? (config?.defaults?.verification?.enabled !== false),
+            }];
     }
     else if (config) {
         // Get skills from matched triggers, preserving remote property and filters
@@ -384,7 +699,18 @@ async function runSkills(context, options, reporter) {
             seen.add(t.skill);
             return true;
         })
-            .map((t) => ({ skill: t.skill, remote: t.remote, filters: t.filters }));
+            .map((t) => ({
+            skill: t.skill,
+            remote: t.remote,
+            filters: t.filters,
+            model: t.model,
+            maxTurns: t.maxTurns,
+            runtime: t.runtime,
+            auxiliaryModel: t.auxiliaryModel,
+            synthesisModel: t.synthesisModel,
+            auxiliaryMaxRetries: t.auxiliaryMaxRetries,
+            verifyFindings: t.verifyFindings,
+        }));
     }
     else {
         skillsToRun = [];
@@ -402,30 +728,54 @@ async function runSkills(context, options, reporter) {
         return 0;
     }
     // Build skill tasks
-    // Model precedence: defaults.model > CLI flag > WARDEN_MODEL env var > SDK default
+    // Model precedence: defaults.agent.model > defaults.model > CLI flag > WARDEN_MODEL env var > SDK default
     // sdkModel is undefined when no model is explicitly configured (lets SDK use its default).
     // logModel records what was used for JSONL logs (sentinel when no explicit model).
-    const sdkModel = config?.defaults?.model ?? options.model ?? process.env['WARDEN_MODEL'];
-    const logModel = sdkModel ?? MODEL_DEFAULT_SENTINEL;
+    const sdkModel = defaultModel;
+    const logModel = resolveCliLogModel(config, options.model);
     const runnerOptions = {
         apiKey,
         model: sdkModel,
+        runtime: config?.defaults?.runtime ?? 'claude',
+        auxiliaryModel: defaultAuxiliaryModel,
+        synthesisModel: defaultSynthesisModel,
         abortController,
-        maxTurns: config?.defaults?.maxTurns,
+        maxTurns: config?.defaults?.agent?.maxTurns ?? config?.defaults?.maxTurns,
         batchDelayMs: config?.defaults?.batchDelayMs,
         maxContextFiles: config?.defaults?.chunking?.maxContextFiles,
-        auxiliaryMaxRetries: config?.defaults?.auxiliaryMaxRetries,
+        auxiliaryMaxRetries: config?.defaults?.auxiliary?.maxRetries ??
+            config?.defaults?.auxiliaryMaxRetries,
+        verifyFindings: config?.defaults?.verification?.enabled !== false,
     };
-    const tasks = skillsToRun.map(({ skill, remote, filters }) => ({
+    const specs = skillsToRun.map(({ skill, remote, filters, ...skillOptions }) => ({
         name: skill,
+        skill,
+        remote,
         failOn: options.failOn,
-        resolveSkill: () => resolveSkillAsync(skill, repoPath, {
-            remote,
-            offline: options.offline,
-        }),
         context: filterContextByPaths(context, filters),
-        runnerOptions,
+        runnerOptions: mergeSkillRunnerOptions(runnerOptions, skillOptions),
     }));
+    let tasks;
+    const concurrency = options.parallel ?? DEFAULT_CONCURRENCY;
+    try {
+        tasks = await createSkillTasks({
+            specs,
+            repoPath,
+            options,
+            parallel: concurrency,
+            reporter,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reporter.error(message);
+        emitEmptyRunLog(repoPath ?? cwd, options, {
+            code: 'unknown',
+            message,
+            timestamp: new Date().toISOString(),
+        });
+        return 1;
+    }
     // Open the run's JSONL log before launching skills so `warden runs
     // follow <runId>` works from a second terminal while the run is live.
     const runId = generateRunId();
@@ -450,14 +800,14 @@ async function runSkills(context, options, reporter) {
         startTime,
     });
     // Run skills with Ink UI (TTY) or simple console output (non-TTY)
-    const concurrency = options.parallel ?? DEFAULT_CONCURRENCY;
     failFastController = options.failFast ? new AbortController() : undefined;
     const taskOptions = {
         mode: reporter.mode,
         verbosity: reporter.verbosity,
         concurrency,
         failFastController,
-        onSkillComplete: (report) => appendSkillToRunLog(runLog, report),
+        onChunkComplete: (skillName, chunk) => appendChunkToRunLog(runLog, skillName, chunk),
+        onSkillComplete: (report) => appendReportToRunLog(runLog, report),
     };
     const results = reporter.mode.isTTY
         ? await runSkillTasksWithInk(tasks, taskOptions)
@@ -468,9 +818,6 @@ async function runSkills(context, options, reporter) {
     const processed = processTaskResults(results, options.reportOn, effectiveMinConfidence);
     return outputResultsAndHandleFixes(processed, options, reporter, runLog, totalDuration, failFastController?.signal.aborted);
 }
-/**
- * Run in file mode: analyze specific files.
- */
 async function runFileMode(filePatterns, options, reporter) {
     const cwd = process.cwd();
     // Build context from files
@@ -513,9 +860,6 @@ function parseGitRef(ref) {
     }
     return { base: ref, head: 'HEAD' };
 }
-/**
- * Run in git ref mode: analyze changes from a git ref.
- */
 async function runGitRefMode(gitRef, options, reporter) {
     const cwd = process.cwd();
     let repoPath;
@@ -565,9 +909,6 @@ async function runGitRefMode(gitRef, options, reporter) {
     reporter.contextFiles(pullRequest.files);
     return runSkills(context, options, reporter);
 }
-/**
- * Run in config mode: use warden.toml triggers.
- */
 async function runConfigMode(options, reporter) {
     const cwd = process.cwd();
     let repoPath;
@@ -589,13 +930,18 @@ async function runConfigMode(options, reporter) {
     }
     // Load config
     const config = loadWardenConfig(dirname(configPath));
-    // Build context from local git — default to HEAD so only uncommitted changes are analyzed
-    const statusMessage = options.staged ? 'Analyzing staged changes...' : 'Analyzing uncommitted changes...';
+    // Build context from local git. By default, mirror PR-style analysis:
+    // compare the configured/default branch merge base to HEAD.
+    const localReviewBase = resolveLocalReviewBase(config.defaults?.defaultBranch, repoPath);
+    const statusMessage = options.staged
+        ? 'Analyzing staged changes...'
+        : `Analyzing changes from ${localReviewBase.base} to HEAD...`;
     reporter.startContext(statusMessage);
     const context = buildLocalEventContext({
-        base: 'HEAD',
+        base: options.staged ? 'HEAD' : localReviewBase.base,
+        head: options.staged ? undefined : 'HEAD',
         cwd: repoPath,
-        defaultBranch: config.defaults?.defaultBranch,
+        defaultBranch: localReviewBase.defaultBranch,
         staged: options.staged,
     });
     const pullRequest = context.pullRequest;
@@ -610,10 +956,7 @@ async function runConfigMode(options, reporter) {
                 reporter.renderEmptyState('No staged changes found');
             }
             else {
-                const tip = !hasUncommittedChanges(repoPath)
-                    ? 'Specify a git ref: warden HEAD~3 --skill <name>'
-                    : undefined;
-                reporter.renderEmptyState('No uncommitted changes found', tip);
+                reporter.renderEmptyState(`No changes found from ${pullRequest.baseBranch} to HEAD`, 'Use --staged to analyze staged changes');
             }
             reporter.blank();
         }
@@ -659,7 +1002,6 @@ async function runConfigMode(options, reporter) {
     if (!apiKey) {
         reporter.debug('No API key found. Using Claude Code subscription auth.');
     }
-    // Pre-flight: verify auth will work before starting analysis
     try {
         verifyAuth({ apiKey });
     }
@@ -675,31 +1017,54 @@ async function runConfigMode(options, reporter) {
     }
     // Build trigger tasks
     const effectiveMinConfidence = options.minConfidence ?? config.defaults?.minConfidence ?? 'medium';
-    const tasks = triggersToRun.map((trigger) => ({
+    const specs = triggersToRun.map((trigger) => ({
         name: trigger.name,
         displayName: trigger.skill,
+        skill: trigger.skill,
+        remote: trigger.remote,
         failOn: trigger.failOn ?? options.failOn,
         minConfidence: trigger.minConfidence ?? effectiveMinConfidence,
-        resolveSkill: () => resolveSkillAsync(trigger.skill, repoPath, {
-            remote: trigger.remote,
-            offline: options.offline,
-        }),
         context: filterContextByPaths(context, trigger.filters),
         runnerOptions: {
             apiKey,
             model: trigger.model,
+            runtime: trigger.runtime,
+            auxiliaryModel: trigger.auxiliaryModel,
+            synthesisModel: trigger.synthesisModel,
             abortController,
             maxTurns: trigger.maxTurns,
             maxContextFiles: config.defaults?.chunking?.maxContextFiles,
-            auxiliaryMaxRetries: config.defaults?.auxiliaryMaxRetries,
+            auxiliaryMaxRetries: trigger.auxiliaryMaxRetries,
+            verifyFindings: trigger.verifyFindings,
         },
     }));
+    let tasks;
+    const concurrency = options.parallel ?? config.runner?.concurrency ?? DEFAULT_CONCURRENCY;
+    try {
+        tasks = await createSkillTasks({
+            specs,
+            repoPath,
+            options,
+            parallel: concurrency,
+            reporter,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reporter.error(message);
+        emitEmptyRunLog(repoPath, options, {
+            code: 'unknown',
+            message,
+            timestamp: new Date().toISOString(),
+        });
+        return 1;
+    }
     // Initialize the run's JSONL log up front so a second terminal can
     // `warden runs follow <runId>` while skills are still running.
     // Skill records are appended on each completion; the trailing summary
     // is appended in `outputResultsAndHandleFixes`.
     // Run-level model is the default (ignoring per-trigger overrides); per-skill models are on each report.
-    const defaultModel = config.defaults?.model ?? options.model ?? process.env['WARDEN_MODEL'] ?? MODEL_DEFAULT_SENTINEL;
+    const defaultModel = resolveCliLogModel(config, options.model);
     const runId = generateRunId();
     const timestamp = new Date();
     const traceId = getTraceId();
@@ -722,14 +1087,14 @@ async function runConfigMode(options, reporter) {
         startTime,
     });
     // Run triggers with Ink UI (TTY) or simple console output (non-TTY)
-    const concurrency = options.parallel ?? config.runner?.concurrency ?? DEFAULT_CONCURRENCY;
     failFastController = options.failFast ? new AbortController() : undefined;
     const taskOptions = {
         mode: reporter.mode,
         verbosity: reporter.verbosity,
         concurrency,
         failFastController,
-        onSkillComplete: (report) => appendSkillToRunLog(runLog, report),
+        onChunkComplete: (skillName, chunk) => appendChunkToRunLog(runLog, skillName, chunk),
+        onSkillComplete: (report) => appendReportToRunLog(runLog, report),
     };
     const results = reporter.mode.isTTY
         ? await runSkillTasksWithInk(tasks, taskOptions)
@@ -739,10 +1104,6 @@ async function runConfigMode(options, reporter) {
     const processed = processTaskResults(results, options.reportOn, effectiveMinConfidence);
     return outputResultsAndHandleFixes(processed, options, reporter, runLog, totalDuration, failFastController?.signal.aborted);
 }
-/**
- * Run in direct skill mode: run a specific skill on uncommitted changes.
- * Used when --skill is specified without targets.
- */
 async function runDirectSkillMode(options, reporter) {
     const cwd = process.cwd();
     let repoPath;
@@ -757,13 +1118,18 @@ async function runDirectSkillMode(options, reporter) {
     // Load config to get defaultBranch if available
     const configPath = resolveConfigPath(options, repoPath);
     const config = existsSync(configPath) ? loadWardenConfig(dirname(configPath)) : null;
-    // Build context from local git - compare against HEAD for true uncommitted changes
-    const statusMessage = options.staged ? 'Analyzing staged changes...' : 'Analyzing uncommitted changes...';
+    // Build context from local git. By default, mirror PR-style analysis:
+    // compare the configured/default branch merge base to HEAD.
+    const localReviewBase = resolveLocalReviewBase(config?.defaults?.defaultBranch, repoPath);
+    const statusMessage = options.staged
+        ? 'Analyzing staged changes...'
+        : `Analyzing changes from ${localReviewBase.base} to HEAD...`;
     reporter.startContext(statusMessage);
     const context = buildLocalEventContext({
-        base: 'HEAD',
+        base: options.staged ? 'HEAD' : localReviewBase.base,
+        head: options.staged ? undefined : 'HEAD',
         cwd: repoPath,
-        defaultBranch: config?.defaults?.defaultBranch,
+        defaultBranch: localReviewBase.defaultBranch,
         staged: options.staged,
     });
     const pullRequest = context.pullRequest;
@@ -778,8 +1144,7 @@ async function runDirectSkillMode(options, reporter) {
                 reporter.renderEmptyState('No staged changes found');
             }
             else {
-                const tip = 'Specify a git ref to analyze committed changes: warden main --skill <name>';
-                reporter.renderEmptyState('No uncommitted changes found', tip);
+                reporter.renderEmptyState(`No changes found from ${pullRequest.baseBranch} to HEAD`, 'Use --staged to analyze staged changes');
             }
             reporter.blank();
         }
@@ -794,7 +1159,7 @@ async function runCommand(options, reporter) {
     if (options.staged && targets.length > 0) {
         reporter.warning('--staged is ignored when targets are specified');
     }
-    // No targets with --skill → run skill directly on uncommitted changes
+    // No targets with --skill → run skill directly on current branch changes
     if (targets.length === 0 && options.skill) {
         return runDirectSkillMode(options, reporter);
     }
@@ -824,16 +1189,31 @@ async function runCommand(options, reporter) {
     // File mode
     return runFileMode(filePatterns, options, reporter);
 }
+/** Parse CLI input, dispatch the selected command, and perform shutdown cleanup. */
 export async function main() {
-    const { command, options, setupAppOptions, runsOptions } = parseCliArgs();
+    const { command, options, helpTarget, setupAppOptions, runsOptions } = parseCliArgs();
     if (command === 'help') {
-        showHelp();
+        showHelp(helpTarget);
         process.exit(0);
     }
     if (command === 'version') {
         showVersion();
         process.exit(0);
     }
+    const reporter = createReporter(options);
+    const originalCwd = process.cwd();
+    const invocationCwd = resolveInvocationCwd(originalCwd, options.cwd);
+    if (invocationCwd !== originalCwd) {
+        try {
+            process.chdir(invocationCwd);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            reporter.error(`Unable to change to ${invocationCwd}: ${message}`);
+            process.exit(1);
+            return;
+        }
+    }
     // Load environment variables from .env files at CLI entry point.
     // Try repo root first, fall back to cwd if not in a git repo.
     const cwd = process.cwd();
@@ -845,8 +1225,6 @@ export async function main() {
         // Not in a git repo - use cwd
     }
     loadEnvFiles(envDir);
-    // Create reporter based on options
-    const reporter = createReporter(options);
     // Show header (unless JSON output or quiet)
     if (!options.json) {
         reporter.header();
@@ -876,6 +1254,10 @@ export async function main() {
                     process.exit(1);
                 }
                 return runRuns(runsOptions, options, reporter);
+            case 'build':
+                return runBuild(options, reporter, { abortController, interrupted });
+            case 'improve':
+                return runImprove(options, reporter, { abortController, interrupted });
             default:
                 return runCommand(options, reporter);
         }