cclaw-cli 0.48.35 → 0.51.0

package/dist/cli.js

@@ -1,29 +1,19 @@
 #!/usr/bin/env node
-import { createReadStream, existsSync, realpathSync } from "node:fs";
-import { spawn } from "node:child_process";
-import fs from "node:fs/promises";
 import process from "node:process";
 import path from "node:path";
+import { existsSync, realpathSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-import { FLOW_TRACKS, HARNESS_IDS } from "./types.js";
 import { doctorChecks, doctorSucceeded } from "./doctor.js";
 import { initCclaw, syncCclaw, uninstallCclaw, upgradeCclaw } from "./install.js";
 import { error, info } from "./logger.js";
+import { FLOW_TRACKS, HARNESS_IDS } from "./types.js";
 import { archiveRun } from "./runs.js";
 import { CCLAW_VERSION, RUNTIME_ROOT } from "./constants.js";
 import { createDefaultConfig } from "./config.js";
 import { detectHarnesses } from "./init-detect.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { classifyCodexHooksFlag, codexConfigPath, patchCodexHooksFlag, readCodexConfig, writeCodexConfig } from "./codex-feature-flag.js";
-import { runEval } from "./eval/runner.js";
-import { createStderrProgressLogger } from "./eval/progress.js";
-import { writeBaselinesFromReport } from "./eval/baseline.js";
-import { writeJsonReport, writeMarkdownReport } from "./eval/report.js";
-import { formatDiffMarkdown, runEvalDiff } from "./eval/diff.js";
-import { ensureRunDir, generateRunId, isRunAlive, listRuns, readRunStatus, resolveRunId, runLogPath, writeRunStatus } from "./eval/runs.js";
-import { parseModeInput } from "./eval/mode.js";
-import { FLOW_STAGES } from "./types.js";
 import { runInternalCommand } from "./internal/advance-stage.js";
 const INSTALLER_COMMANDS = [
     "init",
@@ -32,7 +22,6 @@ const INSTALLER_COMMANDS = [
     "upgrade",
     "uninstall",
     "archive",
-    "eval",
     "internal"
 ];
 export function usage() {
@@ -49,14 +38,18 @@ Commands:
              Flags: --harnesses=<list>  Comma list of harnesses (claude,cursor,opencode,codex).
                     --no-interactive    Skip interactive prompts even on TTY (for CI/scripts).
   sync       Reconcile generated runtime files with the current config.
+  doctor     Check install/runtime wiring and print concrete fixes for failures.
+             Flags: --explain           Include docs pointers for every check.
+                    --json              Emit machine-readable check results.
+                    --quiet             Show only failing checks.
+                    --only=<filter>     Limit displayed checks (error,warning,hook:,state:,...).
+                    --reconcile-gates   Refresh derived gate status before checking.
   upgrade    Refresh generated files in .cclaw. Preserves your config.yaml.
-  archive    Archive the active run and reset flow state for next feature.
+  archive    Archive the active run and reset flow state for the next run.
              Flags: --name=<slug>        Override archive folder suffix.
                     --skip-retro         Skip retro gate only when runtime allows it.
                     --retro-reason=<txt> Required rationale with --skip-retro.
   uninstall  Remove .cclaw runtime and the generated harness shim files.
-  eval       Run cclaw evals. Maintainer surface — see docs/evals.md.
-             Full flag reference: \`npx cclaw-cli eval --help\` or docs/evals.md.
 
 Global flags:
   -h, --help     Show this help message and exit 0.
@@ -66,15 +59,16 @@ Examples:
   npx cclaw-cli
   npx cclaw-cli init --harnesses=claude,cursor --no-interactive
   npx cclaw-cli sync
-  npx cclaw-cli archive --name=my-feature
+  npx cclaw-cli archive --name=my-run
   npx cclaw-cli upgrade
-  npx cclaw-cli eval --dry-run
 
-Everything operational (retro, archive, worktrees, doctor, learnings)
-happens inside your harness via slash commands. The CLI is just a
-launcher. See README.md for the four user-facing slash commands.
+Happy-path work happens inside your harness via /cc, /cc-next,
+/cc-ideate, and /cc-view. Doctor is an operator/support surface:
+it verifies install/runtime wiring, but a real harness smoke test is
+still needed to prove provider auth and model execution.
 
 Docs:   https://github.com/zuevrs/cclaw
+Local:  docs/config.md and docs/harnesses.md
 Issues: https://github.com/zuevrs/cclaw/issues
 `;
 }
@@ -96,25 +90,6 @@ function parseTrack(raw) {
     }
     return trimmed;
 }
-function parseLegacyTier(raw) {
-    return parseModeInput(raw.toUpperCase(), {
-        source: "cli",
-        raw: `--tier=${raw}`
-    });
-}
-function parseEvalMode(raw) {
-    return parseModeInput(raw, {
-        source: "cli",
-        raw: `--mode=${raw}`
-    });
-}
-function parseEvalStage(raw) {
-    const trimmed = raw.trim();
-    if (!FLOW_STAGES.includes(trimmed)) {
-        throw new Error(`Unknown eval stage: ${raw}. Supported: ${FLOW_STAGES.join(", ")}`);
-    }
-    return trimmed;
-}
 function isInitPromptAllowed(ctx) {
     return Boolean(process.stdin.isTTY && ctx.stdout.isTTY);
 }
@@ -143,20 +118,14 @@ function buildInitSurfacePreview(harnesses) {
         ".cclaw/config.yaml",
         ".cclaw/commands/*.md",
         ".cclaw/skills/*/SKILL.md",
-        ".cclaw/contexts/*.md",
         ".cclaw/templates/*",
         ".cclaw/agents/*.md",
         ".cclaw/hooks/*",
         ".cclaw/rules/**",
-        ".cclaw/adapters/*.md",
-        ".cclaw/custom-skills/README.md",
-        ".cclaw/worktrees/**",
-        ".cclaw/features/** (legacy snapshots, read-only migration)",
         ".cclaw/runs/**",
         ".cclaw/artifacts/**",
         ".cclaw/knowledge.jsonl",
         ".cclaw/state/*.json|*.jsonl",
-        ".cclaw/references/**",
         "AGENTS.md (managed block)"
     ];
     for (const harness of harnesses) {
@@ -380,7 +349,7 @@ function printDoctorText(ctx, checks, options) {
             if (!options.quiet) {
                 ctx.stdout.write(`  details: ${check.details}\n`);
             }
-            if (options.explain) {
+            if (!check.ok || options.explain) {
                 ctx.stdout.write(`  fix: ${check.fix}\n`);
                 if (check.docRef) {
                     ctx.stdout.write(`  docs: ${check.docRef}\n`);
@@ -400,18 +369,6 @@ function printDoctorText(ctx, checks, options) {
         ctx.stdout.write("Doctor status: HEALTHY (no failing error checks)\n");
     }
 }
-function resolveMaxCostOption(fromCli, env) {
-    if (fromCli !== undefined)
-        return { maxCostUsd: fromCli };
-    const raw = env.CCLAW_EVAL_MAX_COST_USD;
-    if (raw === undefined || raw.trim() === "")
-        return {};
-    const value = Number(raw);
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new Error(`CCLAW_EVAL_MAX_COST_USD must be a positive number, got: ${raw}`);
-    }
-    return { maxCostUsd: value };
-}
 function parseArgs(argv) {
     const parsed = {};
     const helpFlag = argv.find((arg) => arg === "--help" || arg === "-h");
@@ -433,41 +390,34 @@ function parseArgs(argv) {
         parsed.internalArgs = [...rest];
         return parsed;
     }
-    // For `eval`, the next non-flag argument is an optional subcommand. Any
-    // subsequent non-flag tokens are captured as evalArgs (consumed by the
-    // subcommand handler). This preserves backwards compat: callers that run
-    // `cclaw eval --dry-run` see no subcommand and no positional args.
-    let flags = rest;
-    if (parsed.command === "eval") {
-        const evalArgs = [];
-        const remainder = [];
-        let sawSubcommand = false;
-        for (const token of rest) {
-            if (token.startsWith("--")) {
-                remainder.push(token);
-                continue;
-            }
-            if (!sawSubcommand) {
-                if (token === "diff") {
-                    parsed.evalSubcommand = "diff";
-                    sawSubcommand = true;
-                }
-                else if (token === "runs") {
-                    parsed.evalSubcommand = "runs";
-                    sawSubcommand = true;
-                }
-                else {
-                    evalArgs.push(token);
-                }
-                continue;
-            }
-            evalArgs.push(token);
+    const flags = rest;
+    const isAllowedForCommand = (flag) => {
+        if (parsed.command === "init") {
+            return flag.startsWith("--harnesses=") ||
+                flag.startsWith("--track=") ||
+                flag.startsWith("--profile=") ||
+                flag === "--interactive" ||
+                flag === "--no-interactive" ||
+                flag === "--dry-run";
+        }
+        if (parsed.command === "doctor") {
+            return flag === "--reconcile-gates" ||
+                flag === "--json" ||
+                flag === "--explain" ||
+                flag === "--quiet" ||
+                flag.startsWith("--only=");
+        }
+        if (parsed.command === "archive") {
+            return flag.startsWith("--name=") ||
+                flag === "--skip-retro" ||
+                flag.startsWith("--retro-reason=");
         }
-        if (evalArgs.length > 0)
-            parsed.evalArgs = evalArgs;
-        flags = remainder;
-    }
+        return false;
+    };
     for (const flag of flags) {
+        if (!isAllowedForCommand(flag)) {
+            throw new Error(`Flag ${flag} is not supported for ${parsed.command ?? "this command"}.`);
+        }
         if (flag.startsWith("--harnesses=")) {
             parsed.harnesses = parseHarnesses(flag.replace("--harnesses=", ""));
             continue;
@@ -523,281 +473,9 @@ function parseArgs(argv) {
             parsed.archiveSkipRetroReason = flag.replace("--retro-reason=", "").trim();
             continue;
         }
-        if (flag.startsWith("--stage=")) {
-            parsed.evalStage = parseEvalStage(flag.replace("--stage=", ""));
-            continue;
-        }
-        if (flag.startsWith("--mode=")) {
-            parsed.evalMode = parseEvalMode(flag.replace("--mode=", ""));
-            continue;
-        }
-        if (flag.startsWith("--tier=")) {
-            parsed.evalMode = parseLegacyTier(flag.replace("--tier=", ""));
-            continue;
-        }
-        if (flag === "--schema-only") {
-            parsed.evalSchemaOnly = true;
-            continue;
-        }
-        if (flag === "--rules") {
-            parsed.evalRules = true;
-            continue;
-        }
-        if (flag === "--judge") {
-            parsed.evalJudge = true;
-            continue;
-        }
-        if (flag === "--no-write") {
-            parsed.evalNoWrite = true;
-            continue;
-        }
-        if (flag === "--update-baseline") {
-            parsed.evalUpdateBaseline = true;
-            continue;
-        }
-        if (flag === "--confirm") {
-            parsed.evalConfirm = true;
-            continue;
-        }
-        if (flag === "--background") {
-            parsed.evalBackground = true;
-            continue;
-        }
-        if (flag.startsWith("--compare-model=")) {
-            const value = flag.replace("--compare-model=", "").trim();
-            if (value.length === 0) {
-                throw new Error(`--compare-model requires a non-empty model id (e.g. --compare-model=gpt-4o-mini).`);
-            }
-            parsed.evalCompareModel = value;
-            continue;
-        }
-        if (flag.startsWith("--max-cost-usd=")) {
-            const raw = flag.replace("--max-cost-usd=", "").trim();
-            const value = Number(raw);
-            if (!Number.isFinite(value) || value <= 0) {
-                throw new Error(`--max-cost-usd requires a positive number, got: ${raw}`);
-            }
-            parsed.evalMaxCostUsd = value;
-            continue;
-        }
-    }
-    // `--json` is shared between doctor and eval. Disambiguate by command.
-    if (parsed.command === "eval" && parsed.doctorJson === true) {
-        parsed.evalJson = true;
-        parsed.doctorJson = undefined;
-    }
-    // `--quiet` on `eval` silences the stderr progress logger. On doctor it
-    // continues to mean "print only failing checks" — the flag slot is the
-    // same, the semantics depend on which command owns the invocation.
-    if (parsed.command === "eval" && parsed.doctorQuiet === true) {
-        parsed.evalQuiet = true;
-        parsed.doctorQuiet = undefined;
     }
     return parsed;
 }
-/**
- * Spawn `cclaw eval` (without `--background`) in a detached child process
- * and return immediately. The child's stdout+stderr are piped to
- * `.cclaw/evals/runs/<id>/run.log` so the user can attach later with
- * `cclaw eval runs tail`. We do NOT wait for the child — the whole point
- * is to free the terminal while a multi-minute workflow-mode run
- * proceeds in the background.
- */
-async function spawnBackgroundEval(parsed, ctx) {
-    const id = generateRunId();
-    await ensureRunDir(ctx.cwd, id);
-    const logPath = runLogPath(ctx.cwd, id);
-    const childArgv = process.argv.slice(2).filter((a) => a !== "--background");
-    const cliEntry = process.argv[1];
-    if (!cliEntry) {
-        error(ctx, "Could not resolve cclaw entrypoint for --background.");
-        return 1;
-    }
-    const logHandle = await fs.open(logPath, "a");
-    try {
-        const child = spawn(process.execPath, [cliEntry, ...childArgv], {
-            cwd: ctx.cwd,
-            detached: true,
-            stdio: ["ignore", logHandle.fd, logHandle.fd],
-            env: process.env
-        });
-        const pid = child.pid ?? -1;
-        await writeRunStatus(ctx.cwd, {
-            id,
-            startedAt: new Date().toISOString(),
-            pid,
-            argv: childArgv,
-            cwd: ctx.cwd,
-            state: "running"
-        });
-        child.unref();
-        const finalize = async (code) => {
-            const current = await readRunStatus(ctx.cwd, id);
-            if (!current)
-                return;
-            const exitCode = typeof code === "number" ? code : -1;
-            await writeRunStatus(ctx.cwd, {
-                ...current,
-                endedAt: new Date().toISOString(),
-                exitCode,
-                state: exitCode === 0 ? "succeeded" : "failed"
-            });
-        };
-        child.on("exit", (code) => {
-            void finalize(code);
-        });
-        child.on("error", (err) => {
-            void writeRunStatus(ctx.cwd, {
-                id,
-                startedAt: new Date().toISOString(),
-                pid,
-                argv: childArgv,
-                cwd: ctx.cwd,
-                endedAt: new Date().toISOString(),
-                exitCode: -1,
-                state: "failed"
-            });
-            error(ctx, `Background eval failed to start: ${err.message}`);
-        });
-        ctx.stdout.write(`cclaw eval: background run id=${id} pid=${pid}\n` +
-            `  log:    ${logPath}\n` +
-            `  tail:   cclaw eval runs tail ${id}\n` +
-            `  status: cclaw eval runs status ${id}\n`);
-        return 0;
-    }
-    finally {
-        await logHandle.close();
-    }
-}
-function formatRunRow(status) {
-    const ended = status.endedAt ? ` ended=${status.endedAt}` : "";
-    const exitCode = status.exitCode !== undefined ? ` exit=${status.exitCode}` : "";
-    const alive = status.state === "running" ? (isRunAlive(status) ? "" : " (stale)") : "";
-    return `${status.id}  state=${status.state}${alive}  pid=${status.pid}  started=${status.startedAt}${ended}${exitCode}`;
-}
-async function runEvalRunsSubcommand(parsed, ctx) {
-    const args = parsed.evalArgs ?? [];
-    const action = args[0] ?? "list";
-    if (action === "list") {
-        const runs = await listRuns(ctx.cwd);
-        if (runs.length === 0) {
-            ctx.stdout.write("No eval runs recorded under .cclaw/evals/runs/.\n");
-            return 0;
-        }
-        if (parsed.evalJson === true) {
-            ctx.stdout.write(`${JSON.stringify(runs, null, 2)}\n`);
-            return 0;
-        }
-        for (const run of runs)
-            ctx.stdout.write(`${formatRunRow(run)}\n`);
-        return 0;
-    }
-    if (action === "status") {
-        const id = await resolveRunId(ctx.cwd, args[1]);
-        if (!id) {
-            error(ctx, `No such run: ${args[1] ?? "(none recorded)"}`);
-            return 1;
-        }
-        const status = await readRunStatus(ctx.cwd, id);
-        if (!status) {
-            error(ctx, `Run ${id} has no status file.`);
-            return 1;
-        }
-        if (parsed.evalJson === true) {
-            ctx.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
-        }
-        else {
-            ctx.stdout.write(`${formatRunRow(status)}\n`);
-            ctx.stdout.write(`log: ${runLogPath(ctx.cwd, id)}\n`);
-        }
-        return status.state === "failed" ? 1 : 0;
-    }
-    if (action === "tail") {
-        const id = await resolveRunId(ctx.cwd, args[1]);
-        if (!id) {
-            error(ctx, `No such run: ${args[1] ?? "(none recorded)"}`);
-            return 1;
-        }
-        const logFile = runLogPath(ctx.cwd, id);
-        const stream = createReadStream(logFile, { encoding: "utf8" });
-        await new Promise((resolve, reject) => {
-            stream.on("data", (chunk) => ctx.stdout.write(chunk));
-            stream.on("end", () => resolve());
-            stream.on("error", reject);
-        });
-        return 0;
-    }
-    error(ctx, `Unknown \`cclaw eval runs\` action: ${action}. Use list | status | tail.`);
-    return 1;
-}
-/**
- * Run the same corpus twice — once against the configured model, once
- * against `--compare-model=<id>` — and print a summary comparing the
- * two. Both reports are written to `.cclaw/evals/reports/` (unless
- * `--no-write` is set) and a unified diff is emitted to stdout. Exit
- * code is 1 when the override model regressed against the baseline
- * model, 0 otherwise.
- */
-async function runCompareModel(parsed, ctx, progress) {
-    const baselineOpts = {
-        projectRoot: ctx.cwd,
-        stage: parsed.evalStage,
-        mode: parsed.evalMode,
-        schemaOnly: parsed.evalSchemaOnly === true,
-        rules: parsed.evalRules === true,
-        judge: parsed.evalJudge === true,
-        ...(progress ? { progress } : {}),
-        ...resolveMaxCostOption(parsed.evalMaxCostUsd, process.env)
-    };
-    ctx.stderr.write(`[cclaw eval] compare: running baseline model...\n`);
-    const baseline = await runEval(baselineOpts);
-    if ("kind" in baseline) {
-        error(ctx, "--compare-model is incompatible with --dry-run.");
-        return 1;
-    }
-    ctx.stderr.write(`[cclaw eval] compare: running ${parsed.evalCompareModel} ...\n`);
-    const candidate = await runEval({
-        ...baselineOpts,
-        modelOverride: parsed.evalCompareModel
-    });
-    if ("kind" in candidate) {
-        error(ctx, "--compare-model received an unexpected dry-run response.");
-        return 1;
-    }
-    if (parsed.evalNoWrite !== true) {
-        await writeJsonReport(ctx.cwd, baseline);
-        await writeMarkdownReport(ctx.cwd, baseline);
-        await writeJsonReport(ctx.cwd, candidate);
-        await writeMarkdownReport(ctx.cwd, candidate);
-    }
-    const passDelta = candidate.summary.passed - baseline.summary.passed;
-    const failDelta = candidate.summary.failed - baseline.summary.failed;
-    const costDelta = candidate.summary.totalCostUsd - baseline.summary.totalCostUsd;
-    if (parsed.evalJson === true) {
-        ctx.stdout.write(`${JSON.stringify({
-            baseline: {
-                model: baseline.model,
-                summary: baseline.summary
-            },
-            candidate: {
-                model: candidate.model,
-                summary: candidate.summary
-            },
-            delta: { passed: passDelta, failed: failDelta, costUsd: costDelta }
-        }, null, 2)}\n`);
-    }
-    else {
-        ctx.stdout.write(`cclaw eval compare-model:\n` +
-            `  baseline   ${baseline.model}: pass=${baseline.summary.passed}/${baseline.summary.totalCases} ` +
-            `fail=${baseline.summary.failed} cost=$${baseline.summary.totalCostUsd.toFixed(4)}\n` +
-            `  candidate  ${candidate.model}: pass=${candidate.summary.passed}/${candidate.summary.totalCases} ` +
-            `fail=${candidate.summary.failed} cost=$${candidate.summary.totalCostUsd.toFixed(4)}\n` +
-            `  delta: passed=${passDelta >= 0 ? "+" : ""}${passDelta} ` +
-            `failed=${failDelta >= 0 ? "+" : ""}${failDelta} ` +
-            `cost=${costDelta >= 0 ? "+" : ""}$${costDelta.toFixed(4)}\n`);
-    }
-    return failDelta > 0 ? 1 : 0;
-}
 async function runCommand(parsed, ctx) {
     if (parsed.showHelp) {
         ctx.stdout.write(usage());
@@ -868,7 +546,8 @@ async function runCommand(parsed, ctx) {
         if (parsed.doctorJson === true) {
             const counts = doctorCountsBySeverity(filteredChecks);
             ctx.stdout.write(`${JSON.stringify({
-                ok: doctorSucceeded(checks),
+                ok: doctorSucceeded(filteredChecks),
+                globalOk: doctorSucceeded(checks),
                 filters: parsed.doctorOnly ?? [],
                 counts,
                 checks: filteredChecks
@@ -882,138 +561,13 @@ async function runCommand(parsed, ctx) {
                 printDoctorText(ctx, filteredChecks, { explain, quiet });
             }
         }
-        return doctorSucceeded(checks) ? 0 : 2;
+        return doctorSucceeded(filteredChecks) ? 0 : 2;
     }
     if (command === "upgrade") {
         await upgradeCclaw(ctx.cwd);
         info(ctx, "Upgraded .cclaw runtime and regenerated generated files");
         return 0;
     }
-    if (command === "eval" && parsed.evalSubcommand === "runs") {
-        return runEvalRunsSubcommand(parsed, ctx);
-    }
-    if (command === "eval" && parsed.evalBackground === true) {
-        return spawnBackgroundEval(parsed, ctx);
-    }
-    if (command === "eval" && parsed.evalSubcommand === "diff") {
-        const args = parsed.evalArgs ?? [];
-        if (args.length !== 2) {
-            error(ctx, `\`cclaw eval diff\` requires two arguments: <old> <new>. ` +
-                `Example: cclaw eval diff 0.26.0 latest`);
-            return 1;
-        }
-        const [oldSel, newSel] = args;
-        try {
-            const diff = await runEvalDiff({
-                projectRoot: ctx.cwd,
-                old: oldSel,
-                new: newSel
-            });
-            if (parsed.evalJson === true) {
-                ctx.stdout.write(`${JSON.stringify(diff, null, 2)}\n`);
-            }
-            else {
-                ctx.stdout.write(formatDiffMarkdown(diff));
-            }
-            return diff.regressed ? 1 : 0;
-        }
-        catch (err) {
-            error(ctx, err instanceof Error ? err.message : String(err));
-            return 1;
-        }
-    }
-    if (command === "eval") {
-        const wantProgress = parsed.evalQuiet !== true &&
-            parsed.dryRun !== true &&
-            parsed.evalJson !== true;
-        const progress = wantProgress
-            ? createStderrProgressLogger({ writer: (s) => ctx.stderr.write(s) })
-            : undefined;
-        if (parsed.evalCompareModel !== undefined) {
-            return runCompareModel(parsed, ctx, progress);
-        }
-        const result = await runEval({
-            projectRoot: ctx.cwd,
-            stage: parsed.evalStage,
-            mode: parsed.evalMode,
-            schemaOnly: parsed.evalSchemaOnly === true,
-            rules: parsed.evalRules === true,
-            judge: parsed.evalJudge === true,
-            dryRun: parsed.dryRun === true,
-            ...(progress ? { progress } : {}),
-            ...resolveMaxCostOption(parsed.evalMaxCostUsd, process.env)
-        });
-        if ("kind" in result) {
-            if (parsed.evalJson === true) {
-                ctx.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-                return 0;
-            }
-            ctx.stdout.write(`cclaw eval dry-run\n`);
-            ctx.stdout.write(`  provider: ${result.config.provider}\n`);
-            ctx.stdout.write(`  baseUrl: ${result.config.baseUrl}\n`);
-            ctx.stdout.write(`  model: ${result.config.model}\n`);
-            ctx.stdout.write(`  source: ${result.config.source}\n`);
-            ctx.stdout.write(`  apiKey: ${result.config.apiKey ? "set" : "unset"}\n`);
-            ctx.stdout.write(`  mode: ${result.plannedMode}\n`);
-            ctx.stdout.write(`  corpus: ${result.corpus.total} case(s)\n`);
-            for (const [stage, count] of Object.entries(result.corpus.byStage)) {
-                ctx.stdout.write(`    - ${stage}: ${count}\n`);
-            }
-            if (result.workflowCorpus.total > 0 || result.plannedMode === "workflow") {
-                ctx.stdout.write(`  workflow corpus: ${result.workflowCorpus.total} case(s)\n`);
-                for (const wf of result.workflowCorpus.cases) {
-                    ctx.stdout.write(`    - ${wf.id}: ${wf.stages.join(" → ")}\n`);
-                }
-            }
-            ctx.stdout.write(`  verifiers available:\n`);
-            for (const [key, value] of Object.entries(result.verifiersAvailable)) {
-                ctx.stdout.write(`    - ${key}: ${value ? "yes" : "no"}\n`);
-            }
-            if (result.notes.length > 0) {
-                ctx.stdout.write(`  notes:\n`);
-                for (const note of result.notes) {
-                    ctx.stdout.write(`    - ${note}\n`);
-                }
-            }
-            return 0;
-        }
-        if (parsed.evalUpdateBaseline === true && parsed.evalConfirm !== true) {
-            error(ctx, "--update-baseline requires --confirm to prevent accidental baseline resets.");
-            return 1;
-        }
-        if (parsed.evalUpdateBaseline === true) {
-            if (result.summary.failed > 0) {
-                error(ctx, `Refusing to update baselines: ${result.summary.failed} case(s) currently failing. Fix structural checks first.`);
-                return 1;
-            }
-            const written = await writeBaselinesFromReport(ctx.cwd, result);
-            for (const file of written) {
-                info(ctx, `Baseline written: ${path.relative(ctx.cwd, file)}`);
-            }
-        }
-        if (parsed.evalNoWrite !== true) {
-            const jsonPath = await writeJsonReport(ctx.cwd, result);
-            const mdPath = await writeMarkdownReport(ctx.cwd, result);
-            info(ctx, `Report written: ${path.relative(ctx.cwd, jsonPath)}`);
-            info(ctx, `Report written: ${path.relative(ctx.cwd, mdPath)}`);
-        }
-        const regressionCount = result.baselineDelta?.criticalFailures ?? 0;
-        if (parsed.evalJson === true) {
-            ctx.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        }
-        else {
-            const regressionNote = regressionCount > 0 ? `, ${regressionCount} regression(s)` : "";
-            ctx.stdout.write(`cclaw eval: ${result.summary.totalCases} case(s), ` +
-                `${result.summary.passed} passed, ` +
-                `${result.summary.failed} failed, ` +
-                `${result.summary.skipped} skipped${regressionNote}\n`);
-        }
-        if (result.summary.failed > 0)
-            return 1;
-        if (regressionCount > 0)
-            return 1;
-        return 0;
-    }
     if (command === "archive") {
         const archived = await archiveRun(ctx.cwd, parsed.archiveName, {
             skipRetro: parsed.archiveSkipRetro === true,
@@ -1025,13 +579,13 @@ async function runCommand(parsed, ctx) {
         info(ctx, `Archived active artifacts to ${archived.archivePath}. Flow state reset to brainstorm.${snapshotSummary}`);
         const k = archived.knowledge;
         if (k.overThreshold) {
-            info(ctx, `Knowledge curation recommended: ${k.knowledgePath} now has ${k.activeEntryCount} active entries (soft threshold ${k.softThreshold}). Run \`/cc-learn curate\` to plan a soft-archive of stale/duplicate entries to ${RUNTIME_ROOT}/knowledge.archive.jsonl.`);
+            info(ctx, `Knowledge curation recommended: ${k.knowledgePath} now has ${k.activeEntryCount} active entries (soft threshold ${k.softThreshold}). Ask your harness to curate cclaw knowledge and plan a soft-archive of stale/duplicate entries to ${RUNTIME_ROOT}/knowledge.archive.jsonl.`);
         }
         else if (k.activeEntryCount > 0) {
-            info(ctx, `Knowledge: ${k.activeEntryCount}/${k.softThreshold} active entries. Run \`/cc-learn curate\` if you want a sweep before the next run.`);
+            info(ctx, `Knowledge: ${k.activeEntryCount}/${k.softThreshold} active entries. Ask your harness for a cclaw knowledge curation sweep before the next run if needed.`);
         }
         else {
-            info(ctx, `Knowledge: 0 active entries in ${k.knowledgePath}. Capture lessons from this run with \`/cc-learn add\` before they fade.`);
+            info(ctx, `Knowledge: 0 active entries in ${k.knowledgePath}. Capture lessons from this run through the learnings skill before they fade.`);
         }
         return 0;
     }
@@ -1040,13 +594,13 @@ async function runCommand(parsed, ctx) {
     return 0;
 }
 async function main() {
-    const parsed = parseArgs(process.argv.slice(2));
     const ctx = {
         cwd: process.cwd(),
         stdout: process.stdout,
         stderr: process.stderr
     };
     try {
+        const parsed = parseArgs(process.argv.slice(2));
         const code = await runCommand(parsed, ctx);
         process.exitCode = code;
     }