cclaw-cli 7.7.0 → 8.1.0

package/dist/cli.js

@@ -1,530 +1,112 @@
 #!/usr/bin/env node
-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 { CCLAW_VERSION } from "./constants.js";
 import { initCclaw, syncCclaw, uninstallCclaw, upgradeCclaw } from "./install.js";
-import { error, info } from "./logger.js";
-import { FLOW_TRACKS, HARNESS_IDS } from "./types.js";
-import { ARCHIVE_DISPOSITIONS, archiveRun } from "./runs.js";
-import { CCLAW_VERSION, RUNTIME_ROOT } from "./constants.js";
-import { createDefaultConfig, readConfig } from "./config.js";
-import { detectHarnesses } from "./init-detect.js";
-import { HARNESS_ADAPTERS } from "./harness-adapters.js";
-import { promptHarnessSelectionChecklist } from "./harness-selection.js";
-export { parseHarnessSelectionAnswer } from "./harness-selection.js";
-import { classifyCodexHooksFlag, codexConfigPath, patchCodexHooksFlag, readCodexConfig, writeCodexConfig } from "./codex-feature-flag.js";
-import { runInternalCommand } from "./internal/advance-stage.js";
-const INSTALLER_COMMANDS = [
-    "init",
-    "sync",
-    "upgrade",
-    "uninstall",
-    "archive",
-    "internal"
-];
-export function usage() {
-    return `cclaw - installer-first flow toolkit
+import { configureLogger, error as logError, info } from "./logger.js";
+import { HARNESS_IDS } from "./types.js";
+const HELP_BODY = `cclaw v${CCLAW_VERSION} — harness installer / sync.
 
-Usage:
-  npx cclaw-cli                   # launch setup or print "already installed" hint
-  npx cclaw-cli <command> [flags]
-  npx cclaw-cli --help | -h
-  npx cclaw-cli --version | -v
+Usage: cclaw <command> [options]
 
 Commands:
-  init       Bootstrap .cclaw runtime, state, and harness shims in this project.
-             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.
-             Flags: --harnesses=<list>  Update configured harnesses before syncing.
-                    --interactive      Pick harnesses from a numbered TTY menu.
-                    --check            Verify managed hook files are byte-identical to canonical generators.
-  upgrade    Refresh generated files in .cclaw. Preserves your config.yaml.
-  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.
-                    --disposition=<completed|cancelled|abandoned>
-                    --reason=<txt>      Required for cancelled/abandoned archives.
-  uninstall  Remove .cclaw runtime and the generated harness shim files.
+  init                Install cclaw assets in the current project.
+  sync                Reapply cclaw assets to match the current code (idempotent).
+  upgrade             Sync after upgrading the cclaw-cli npm package.
+  uninstall           Remove cclaw assets from the current project.
+  help                Show this help.
+  version             Print the version.
 
-Global flags:
-  -h, --help     Show this help message and exit 0.
-  -v, --version  Print the cclaw CLI version and exit 0.
+Harness selection:
+  - If --harness=<id>[,<id>] is passed, install for those.
+  - Otherwise, the existing .cclaw/config.yaml (if any) wins.
+  - Otherwise, cclaw auto-detects from project root markers (.claude/, .cursor/,
+    .opencode/, .codex/, .agents/skills/, CLAUDE.md, opencode.json).
+  - If nothing is detected and no flag is passed, init exits with an error.
 
-Examples:
-  npx cclaw-cli
-  npx cclaw-cli init --harnesses=claude,cursor --no-interactive
-  npx cclaw-cli sync --interactive
-  npx cclaw-cli sync --check
-  npx cclaw-cli archive --name=my-run
-  npx cclaw-cli archive --disposition=cancelled --reason="deprioritized"
-  npx cclaw-cli upgrade
+Flow control (plan / build / review / ship) lives inside the harness via the /cc command, not in this CLI. There is no \`cclaw plan\`, \`cclaw status\`, \`cclaw ship\`, or \`cclaw migrate\` — by design.
 
-Happy-path work happens inside your harness via /cc, /cc-idea,
-and /cc-cancel. Installer/support operations are init/sync/upgrade/uninstall
-plus explicit archive actions.
-
-Docs:   https://github.com/zuevrs/cclaw
-Local:  README.md and generated .cclaw/skills/*.md
-Issues: https://github.com/zuevrs/cclaw/issues
+Options:
+  --harness=<id>[,<id>]  Comma-separated list. Supported: ${HARNESS_IDS.join(", ")}.
 `;
-}
-function parseHarnesses(raw) {
-    const requested = raw
-        .split(",")
-        .map((item) => item.trim())
-        .filter(Boolean);
-    if (requested.length === 0) {
-        throw new Error("Select at least one harness.");
-    }
-    const invalid = requested.filter((item) => !HARNESS_IDS.includes(item));
-    if (invalid.length > 0) {
-        throw new Error(`Unknown harnesses: ${invalid.join(", ")}`);
-    }
-    return requested;
-}
-function parseTrack(raw) {
-    const trimmed = raw.trim();
-    if (!FLOW_TRACKS.includes(trimmed)) {
-        throw new Error(`Unknown track: ${trimmed}. Supported: ${FLOW_TRACKS.join(", ")}`);
-    }
-    return trimmed;
-}
-function parseArchiveDisposition(raw) {
-    const trimmed = raw.trim();
-    if (!ARCHIVE_DISPOSITIONS.includes(trimmed)) {
-        throw new Error(`Unknown archive disposition: ${trimmed}. Supported: ${ARCHIVE_DISPOSITIONS.join(", ")}`);
-    }
-    return trimmed;
-}
-function isInitPromptAllowed(ctx) {
-    return Boolean(process.stdin.isTTY && ctx.stdout.isTTY);
-}
-/**
- * Print a short, friendly hint when the user runs `cclaw-cli` with no
- * arguments. Does not read or mutate flow state — only checks whether
- * `.cclaw/config.yaml` exists to branch between "installed" and
- * "not-installed" messaging. Keeps exit 0 in both cases: users discover
- * the tool through this path, not through an error.
- */
-function printNoArgsHint(ctx) {
-    const installed = existsSync(path.join(ctx.cwd, RUNTIME_ROOT, "config.yaml"));
-    if (installed) {
-        ctx.stdout.write("cclaw is installed in this project. Open your harness (Claude Code, " +
-            "Cursor, OpenCode, or Codex) and type `/cc` to start.\n");
-    }
-    else {
-        ctx.stdout.write("cclaw is not installed in this project yet.\n" +
-            "Run `npx cclaw-cli init` to bootstrap .cclaw and the harness shims.\n" +
-            "For help: `npx cclaw-cli --help`.\n");
-    }
-    return 0;
-}
-function buildInitSurfacePreview(harnesses) {
-    const lines = [
-        ".cclaw/config.yaml",
-        ".cclaw/commands/*.md",
-        ".cclaw/skills/*/SKILL.md",
-        ".cclaw/templates/*",
-        ".cclaw/agents/*.md",
-        ".cclaw/hooks/*",
-        ".cclaw/rules/**",
-        ".cclaw/archive/**",
-        ".cclaw/artifacts/**",
-        ".cclaw/knowledge.jsonl",
-        ".cclaw/state/*.json|*.jsonl",
-        "AGENTS.md (managed block)"
-    ];
-    for (const harness of harnesses) {
-        const adapter = HARNESS_ADAPTERS[harness];
-        if (adapter.shimKind === "skill") {
-            lines.push(`${adapter.commandDir}/cc*/SKILL.md`);
-        }
-        else {
-            lines.push(`${adapter.commandDir}/cc*.md`);
-        }
-        if (harness === "claude") {
-            lines.push(".claude/hooks/hooks.json");
-        }
-        if (harness === "cursor") {
-            lines.push(".cursor/hooks.json");
-            lines.push(".cursor/rules/cclaw-workflow.mdc");
-        }
-        if (harness === "codex") {
-            // .codex/hooks.json is managed because Codex CLI
-            // grew a real hooks API (v0.114+, behind the `codex_hooks`
-            // feature flag). Legacy `.codex/commands/*` is still auto-cleaned.
-            lines.push(".codex/hooks.json (requires `codex_hooks = true` in ~/.codex/config.toml)");
-        }
-        if (harness === "opencode") {
-            lines.push(".opencode/plugins/cclaw-plugin.mjs");
-            lines.push("opencode.json(.c) plugin registration");
-        }
-    }
-    return lines;
-}
-async function promptInitConfig(defaults, ctx) {
-    const harnesses = await promptHarnessSelectionChecklist(defaults, ctx, "Initial cclaw harnesses");
-    return { harnesses };
-}
-/**
- * When Codex is one of the installed harnesses, check the Codex CLI
- * config file for the `codex_hooks` feature flag. If it is missing or
- * disabled, offer to patch it in with the user's explicit consent.
- *
- * The function is deliberately advisory: it never fails init — the worst
- * case is that Codex runs without the hooks engine, which is exactly
- * how v0.39.x already shipped. We always print a resolution hint so
- * the user knows what to do next regardless of which branch was taken.
- */
-async function maybeEnableCodexHooksFlag(harnesses, parsed, ctx) {
-    if (!harnesses || !harnesses.includes("codex"))
-        return;
-    const configPath = codexConfigPath();
-    let existing;
-    try {
-        existing = await readCodexConfig(configPath);
-    }
-    catch (err) {
-        ctx.stdout.write(`note: Could not read ${configPath} to check the codex_hooks flag: ` +
-            `${err instanceof Error ? err.message : String(err)}\n`);
-        return;
-    }
-    const state = classifyCodexHooksFlag(existing);
-    if (state === "enabled") {
-        return;
-    }
-    const humanState = state === "missing-file"
-        ? "Codex config file does not exist yet"
-        : state === "missing-section"
-            ? "no [features] section"
-            : state === "missing-key"
-                ? "no codex_hooks key"
-                : "codex_hooks is not enabled";
-    const instructions = `To enable Codex hooks manually later, ensure ${configPath} contains:\n` +
-        `  [features]\n  codex_hooks = true\n`;
-    if (parsed.interactive === false) {
-        ctx.stdout.write(`note: codex_hooks feature flag is not enabled (${humanState}).\n` +
-            `      cclaw wrote .codex/hooks.json, but Codex will ignore it until you enable the flag.\n` +
-            `      ${instructions}`);
-        return;
-    }
-    if (!isInitPromptAllowed(ctx)) {
-        ctx.stdout.write(`note: codex_hooks feature flag is not enabled (${humanState}).\n` +
-            `      cclaw wrote .codex/hooks.json, but Codex will ignore it until you enable the flag.\n` +
-            `      ${instructions}`);
-        return;
-    }
-    const rl = createInterface({
-        input: process.stdin,
-        output: ctx.stdout
-    });
-    try {
-        const answer = (await rl.question(`\nCodex CLI hooks are off (${humanState}).\n` +
-            `Enable [features] codex_hooks = true in ${configPath} now? [y/N]: `)).trim().toLowerCase();
-        const yes = answer === "y" || answer === "yes";
-        if (!yes) {
-            ctx.stdout.write(`Leaving ${configPath} untouched. ${instructions}`);
-            return;
-        }
-        const { updated, changed } = patchCodexHooksFlag(existing);
-        if (!changed) {
-            ctx.stdout.write(`codex_hooks is already enabled — no changes written.\n`);
-            return;
-        }
-        try {
-            await writeCodexConfig(configPath, updated);
-            ctx.stdout.write(`Enabled [features] codex_hooks = true in ${configPath}.\n`);
-        }
-        catch (err) {
-            ctx.stdout.write(`Could not write ${configPath}: ` +
-                `${err instanceof Error ? err.message : String(err)}\n` +
-                `${instructions}`);
-        }
-    }
-    finally {
-        rl.close();
-    }
-}
-async function resolveInitInputs(parsed, ctx) {
-    const detectedHarnesses = parsed.harnesses ? [] : await detectHarnesses(ctx.cwd);
-    const autoHarnesses = parsed.harnesses
-        ? parsed.harnesses
-        : (detectedHarnesses.length > 0 ? detectedHarnesses : undefined);
-    const promptRequested = parsed.interactive === true;
-    const promptForbidden = parsed.interactive === false;
-    const implicitPrompt = !promptForbidden &&
-        isInitPromptAllowed(ctx) &&
-        parsed.track === undefined &&
-        parsed.harnesses === undefined;
-    const shouldPrompt = promptRequested || implicitPrompt;
-    if (!shouldPrompt) {
-        return {
-            track: parsed.track,
-            harnesses: autoHarnesses,
-            detectedHarnesses
-        };
-    }
-    if (!isInitPromptAllowed(ctx)) {
-        throw new Error("Interactive init requires a TTY. Remove --interactive or run in a terminal.");
-    }
-    const defaults = {
-        harnesses: autoHarnesses ?? HARNESS_IDS.slice()
-    };
-    const prompted = await promptInitConfig({ ...defaults, detectedHarnesses }, ctx);
-    return {
-        track: parsed.track,
-        harnesses: prompted.harnesses,
-        detectedHarnesses
-    };
-}
-async function resolveSyncInputs(parsed, ctx) {
-    const explicitHarnesses = parsed.harnesses;
-    if (explicitHarnesses && explicitHarnesses.length > 0) {
-        return { harnesses: explicitHarnesses };
-    }
-    if (parsed.interactive !== true) {
-        return {};
-    }
-    if (!isInitPromptAllowed(ctx)) {
-        throw new Error("Interactive sync requires a TTY. Remove --interactive or run in a terminal.");
-    }
-    let currentHarnesses = [];
-    try {
-        currentHarnesses = (await readConfig(ctx.cwd)).harnesses;
-    }
-    catch {
-        currentHarnesses = [];
-    }
-    const detectedHarnesses = await detectHarnesses(ctx.cwd);
-    const defaults = detectedHarnesses.length > 0 ? detectedHarnesses : currentHarnesses.length > 0 ? currentHarnesses : HARNESS_IDS.slice();
-    return {
-        harnesses: await promptHarnessSelectionChecklist({
-            harnesses: defaults,
-            detectedHarnesses,
-            currentHarnesses
-        }, ctx, "Sync harness reconfiguration")
-    };
-}
 function parseArgs(argv) {
-    const parsed = {};
-    const helpFlag = argv.find((arg) => arg === "--help" || arg === "-h");
-    if (helpFlag) {
-        parsed.showHelp = true;
-    }
-    const versionFlag = argv.find((arg) => arg === "--version" || arg === "-v");
-    if (versionFlag) {
-        parsed.showVersion = true;
-    }
-    const filteredArgv = argv.filter((arg) => arg !== "--help" && arg !== "-h" && arg !== "--version" && arg !== "-v");
-    const [commandRaw, ...rest] = filteredArgv;
-    parsed.command = INSTALLER_COMMANDS.includes(commandRaw)
-        ? commandRaw
-        : undefined;
-    // Hidden maintainer surface for runtime guards/helpers. Keep raw positional
-    // args untouched so subcommand-level parsing can evolve independently.
-    if (parsed.command === "internal") {
-        parsed.internalArgs = [...rest];
-        return parsed;
-    }
-    const flags = rest;
-    const isAllowedForCommand = (flag) => {
-        if (parsed.command === "init" || parsed.command === "sync") {
-            return flag.startsWith("--harnesses=") ||
-                (parsed.command === "init" && flag.startsWith("--track=")) ||
-                (parsed.command === "init" && flag.startsWith("--profile=")) ||
-                (parsed.command === "sync" && flag === "--check") ||
-                flag === "--interactive" ||
-                flag === "--no-interactive" ||
-                (parsed.command === "init" && flag === "--dry-run");
-        }
-        if (parsed.command === "archive") {
-            return flag.startsWith("--name=") ||
-                flag === "--skip-retro" ||
-                flag.startsWith("--retro-reason=") ||
-                flag.startsWith("--disposition=") ||
-                flag.startsWith("--reason=");
-        }
-        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;
-        }
-        if (flag.startsWith("--track=")) {
-            parsed.track = parseTrack(flag.replace("--track=", ""));
-            continue;
-        }
-        if (flag.startsWith("--profile=")) {
-            continue;
-        }
-        if (flag === "--interactive") {
-            parsed.interactive = true;
-            continue;
-        }
-        if (flag === "--no-interactive") {
-            parsed.interactive = false;
-            continue;
-        }
-        if (flag === "--dry-run") {
-            parsed.dryRun = true;
-            continue;
-        }
-        if (flag === "--check") {
-            parsed.syncCheck = true;
-            continue;
-        }
-        if (flag.startsWith("--name=")) {
-            parsed.archiveName = flag.replace("--name=", "").trim();
-            continue;
-        }
-        if (flag === "--skip-retro") {
-            parsed.archiveSkipRetro = true;
-            continue;
-        }
-        if (flag.startsWith("--retro-reason=")) {
-            parsed.archiveSkipRetroReason = flag.replace("--retro-reason=", "").trim();
-            continue;
+    const [command = "help", ...rest] = argv;
+    const flags = {};
+    let harnesses;
+    for (const arg of rest) {
+        if (arg.startsWith("--harness=")) {
+            const list = arg.slice("--harness=".length).split(",").map((value) => value.trim()).filter(Boolean);
+            const invalid = list.filter((value) => !HARNESS_IDS.includes(value));
+            if (invalid.length > 0) {
+                throw new Error(`Unknown harnesses: ${invalid.join(", ")}. Supported: ${HARNESS_IDS.join(", ")}`);
+            }
+            harnesses = list;
         }
-        if (flag.startsWith("--disposition=")) {
-            parsed.archiveDisposition = parseArchiveDisposition(flag.replace("--disposition=", ""));
-            continue;
+        else if (arg.startsWith("--")) {
+            const [name, ...value] = arg.slice(2).split("=");
+            flags[name] = value.length === 0 ? true : value.join("=");
         }
-        if (flag.startsWith("--reason=")) {
-            parsed.archiveDispositionReason = flag.replace("--reason=", "").trim();
-            continue;
+        else {
+            flags._ = arg;
         }
     }
-    return parsed;
+    return { command, harnesses, flags };
 }
-async function runCommand(parsed, ctx) {
-    if (parsed.showHelp) {
-        ctx.stdout.write(usage());
-        return 0;
-    }
-    if (parsed.showVersion) {
-        ctx.stdout.write(`cclaw ${CCLAW_VERSION}\n`);
-        return 0;
-    }
-    const command = parsed.command;
-    if (!command) {
-        return printNoArgsHint(ctx);
-    }
-    if (command === "internal") {
-        return runInternalCommand(ctx.cwd, parsed.internalArgs ?? [], ctx);
-    }
-    if (command === "init") {
-        const resolved = await resolveInitInputs(parsed, ctx);
-        const effectiveTrack = resolved.track;
-        const effectiveHarnesses = resolved.harnesses;
-        if (parsed.dryRun === true) {
-            const previewConfig = createDefaultConfig(effectiveHarnesses, effectiveTrack);
-            const previewSurfaces = buildInitSurfacePreview(previewConfig.harnesses);
-            info(ctx, "Dry run: no files were written.");
-            if (resolved.detectedHarnesses.length > 0 && parsed.harnesses === undefined) {
-                info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
-            }
-            ctx.stdout.write(`${JSON.stringify({
-                track: effectiveTrack ?? "standard",
-                harnesses: previewConfig.harnesses,
-                generatedSurfaces: previewSurfaces
-            }, null, 2)}\n`);
+export async function runCli(argv, context) {
+    configureLogger(context.stdout, context.stderr);
+    const args = parseArgs(argv);
+    switch (args.command) {
+        case "init": {
+            const result = await initCclaw({ cwd: context.cwd, harnesses: args.harnesses });
+            info(`[cclaw] init complete. Harnesses: ${result.installedHarnesses.join(", ")}`);
             return 0;
         }
-        await initCclaw({
-            projectRoot: ctx.cwd,
-            harnesses: effectiveHarnesses,
-            track: effectiveTrack
-        });
-        if (resolved.detectedHarnesses.length > 0 && parsed.harnesses === undefined) {
-            info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
-        }
-        const trackNote = effectiveTrack ? ` (track=${effectiveTrack})` : "";
-        info(ctx, `Initialized .cclaw runtime and generated harness shims${trackNote}`);
-        info(ctx, "Config: .cclaw/config.yaml (harnesses + auto-managed version stamps).");
-        await maybeEnableCodexHooksFlag(effectiveHarnesses, parsed, ctx);
-        return 0;
-    }
-    if (command === "sync") {
-        if (parsed.syncCheck === true) {
-            await syncCclaw(ctx.cwd, { check: true });
-            info(ctx, "Managed hook drift check passed (no sync required).");
+        case "sync": {
+            const result = await syncCclaw({ cwd: context.cwd, harnesses: args.harnesses });
+            info(`[cclaw] sync complete. Harnesses: ${result.installedHarnesses.join(", ")}`);
             return 0;
         }
-        const resolved = await resolveSyncInputs(parsed, ctx);
-        await syncCclaw(ctx.cwd, { harnesses: resolved.harnesses });
-        const harnessNote = resolved.harnesses ? ` (${resolved.harnesses.join(", ")})` : "";
-        info(ctx, `Synchronized harness shims from current .cclaw config${harnessNote}`);
-        return 0;
-    }
-    if (command === "upgrade") {
-        await upgradeCclaw(ctx.cwd);
-        info(ctx, "Upgraded .cclaw runtime and regenerated generated files");
-        return 0;
-    }
-    if (command === "archive") {
-        const archived = await archiveRun(ctx.cwd, parsed.archiveName, {
-            skipRetro: parsed.archiveSkipRetro === true,
-            skipRetroReason: parsed.archiveSkipRetroReason,
-            disposition: parsed.archiveDisposition,
-            dispositionReason: parsed.archiveDispositionReason
-        });
-        const snapshotSummary = archived.snapshottedStateFiles.length > 0
-            ? ` Snapshotted ${archived.snapshottedStateFiles.length} state file(s) under ${archived.archivePath}/state and wrote archive-manifest.json.`
-            : "";
-        info(ctx, `Archived active artifacts to ${archived.archivePath} (${archived.disposition}). 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}). 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. Ask your harness for a cclaw knowledge curation sweep before the next run if needed.`);
+        case "upgrade": {
+            const result = await upgradeCclaw({ cwd: context.cwd, harnesses: args.harnesses });
+            info(`[cclaw] upgrade complete. Harnesses: ${result.installedHarnesses.join(", ")}`);
+            return 0;
         }
-        else {
-            info(ctx, `Knowledge: 0 active entries in ${k.knowledgePath}. Capture lessons from this run through the learnings skill before they fade.`);
+        case "uninstall": {
+            await uninstallCclaw({ cwd: context.cwd });
+            info("[cclaw] uninstall complete.");
+            return 0;
         }
-        return 0;
-    }
-    await uninstallCclaw(ctx.cwd);
-    info(ctx, "Removed .cclaw runtime and generated shim files");
-    return 0;
-}
-async function main() {
-    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;
-    }
-    catch (err) {
-        error(ctx, err instanceof Error ? err.message : "Unknown error");
-        process.exitCode = 1;
-    }
-}
-function isDirectExecution() {
-    if (!process.argv[1])
-        return false;
-    try {
-        const entryPath = realpathSync(path.resolve(process.argv[1]));
-        const modulePath = realpathSync(fileURLToPath(import.meta.url));
-        return entryPath === modulePath;
-    }
-    catch {
-        return false;
-    }
-}
-if (isDirectExecution()) {
-    void main();
+        case "version":
+        case "--version":
+        case "-v":
+            info(CCLAW_VERSION);
+            return 0;
+        case "help":
+        case "--help":
+        case "-h":
+            info(HELP_BODY);
+            return 0;
+        case "plan":
+        case "status":
+        case "ship":
+        case "migrate":
+        case "build":
+        case "review":
+            logError(`[cclaw] '${args.command}' is not a CLI command in v8. Flow control happens via /cc inside your harness.`);
+            return 2;
+        default:
+            logError(`[cclaw] unknown command: ${args.command}`);
+            logError(HELP_BODY);
+            return 2;
+    }
+}
+const isMain = import.meta.url === `file://${process.argv[1]}`;
+if (isMain) {
+    runCli(process.argv.slice(2), { cwd: process.cwd(), stdout: process.stdout, stderr: process.stderr })
+        .then((code) => {
+        process.exit(code);
+    })
+        .catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[cclaw] ${message}\n`);
+        process.exit(1);
+    });
 }
-export { parseArgs, parseArchiveDisposition, parseHarnesses, parseTrack };

package/dist/compound.d.ts

@@ -0,0 +1,26 @@
+import { type ArtifactStage } from "./artifact-paths.js";
+import { type KnowledgeEntry } from "./knowledge-store.js";
+export interface CompoundQualitySignals {
+    hasArchitectDecision: boolean;
+    reviewIterations: number;
+    securityFlag: boolean;
+    userRequestedCapture: boolean;
+}
+export interface CompoundRunOptions {
+    shipCommit: string;
+    signals: CompoundQualitySignals;
+    refines?: string | null;
+    notes?: string;
+}
+export interface CompoundRunResult {
+    slug: string;
+    shippedDir: string;
+    learningCaptured: boolean;
+    movedArtifacts: ArtifactStage[];
+    knowledgeEntry?: KnowledgeEntry;
+}
+export declare class CompoundError extends Error {
+}
+export declare function shouldCaptureLearning(signals: CompoundQualitySignals): boolean;
+export declare function runCompoundAndShip(projectRoot: string, options: CompoundRunOptions): Promise<CompoundRunResult>;
+export declare function defaultPathsToCheck(projectRoot: string): Promise<string[]>;