coding-agent-harness 1.0.8 → 1.1.0

package/dist/commands/task-command.mjs

@@ -1,21 +1,35 @@
-// @ts-nocheck
-import { confirmTaskReview, createTask, readPresetPackage, buildTaskIndex, createLessonSedimentationTask, archiveTask, listLifecycleTasks, promoteLessonCandidate, reopenTask, softDeleteTask, supersedeTask, updateModuleStep, updateTaskPhase, updateTaskLifecycle, } from "../lib/harness-core.mjs";
+import { createTask, readPresetPackage, buildTaskIndex, createLessonSedimentationTask, archiveTask, deleteTask, listLifecycleTasks, promoteLessonCandidate, reopenTask, supersedeTask, updateModuleStep, updateTaskPhase, updateTaskLifecycle, } from "../lib/harness-core.mjs";
+import { takeRepeatedOptionsFromArgs } from "../lib/command-registry.mjs";
 export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg }) {
     if (command === "new-task") {
         const dryRun = takeFlag("--dry-run");
         const locale = takeOption("--locale", "");
         const title = takeOption("--title", "");
         const moduleKey = takeOption("--module", "");
+        const registerModule = takeFlag("--register-module");
+        const moduleRegistration = {
+            title: takeOption("--module-title", ""),
+            prefix: takeOption("--module-prefix", ""),
+            status: takeOption("--module-status", "planned"),
+            branch: takeOption("--module-branch", ""),
+            owner: takeOption("--module-owner", "coordinator"),
+            currentStep: takeOption("--module-current-step", ""),
+            locale,
+            scope: takeRepeatedOptionsFromArgs(args, "--module-scope"),
+            shared: takeRepeatedOptionsFromArgs(args, "--module-shared"),
+            dependsOn: takeRepeatedOptionsFromArgs(args, "--module-depends-on"),
+        };
         const budget = takeOption("--budget", "standard");
         const preset = takeOption("--preset", "");
         const fromSession = takeOption("--from-session", "");
         const longRunning = takeFlag("--long-running");
         try {
             const parsed = parseNewTaskArgs(args, { preset, fromSession });
-            console.log(JSON.stringify(createTask(parsed.target, parsed.taskId, { title, locale, dryRun, moduleKey, budget, longRunning, preset, fromSession, presetArgs: parsed.presetArgs, automaticTaskId: parsed.automaticTaskId }), null, 2));
+            const createOptions = { title, locale, dryRun, moduleKey, budget, longRunning, preset, fromSession, presetArgs: parsed.presetArgs, automaticTaskId: parsed.automaticTaskId, registerModule, moduleRegistration };
+            console.log(JSON.stringify(invokeCreateTask(parsed.target, parsed.taskId, createOptions), null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
@@ -34,7 +48,7 @@ export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg
             console.log(JSON.stringify(updateTaskPhase(targetArg(), taskId, phaseId, { state, completion, evidenceStatus }), null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
@@ -47,37 +61,19 @@ export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg
             console.error("Missing task id");
             process.exit(2);
         }
-        const lifecycle = {
+        const lifecycleByCommand = {
             "task-start": { event: "task-start", state: "in_progress" },
             "task-log": { event: "task-log", state: "" },
             "task-block": { event: "task-block", state: "blocked" },
             "task-review": { event: "task-review", state: "review" },
             "task-complete": { event: "task-complete", state: "done" },
-        }[command];
+        };
+        const lifecycle = lifecycleByCommand[command];
         try {
             console.log(JSON.stringify(updateTaskLifecycle(targetArg(), taskId, { ...lifecycle, message, evidence }), null, 2));
         }
         catch (error) {
-            console.error(error.message);
-            process.exit(1);
-        }
-        return;
-    }
-    if (command === "review-confirm") {
-        const reviewer = takeOption("--reviewer", "Human Reviewer");
-        const message = takeOption("--message", "");
-        const evidence = takeOption("--evidence", "");
-        const confirmText = takeOption("--confirm", "");
-        const taskId = args.shift();
-        if (!taskId) {
-            console.error("Missing task id");
-            process.exit(2);
-        }
-        try {
-            console.log(JSON.stringify(confirmTaskReview(targetArg(), taskId, { reviewer, message, evidence, confirmText }), null, 2));
-        }
-        catch (error) {
-            console.error(formatTaskCommandError(error));
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
@@ -95,7 +91,7 @@ export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg
             console.log(JSON.stringify(promoteLessonCandidate(targetArg(), taskId, candidateId, { dryRun, apply }), null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
@@ -113,7 +109,7 @@ export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg
             console.log(JSON.stringify(createLessonSedimentationTask(targetArg(), taskId, candidateId, { dryRun, title }), null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
@@ -152,40 +148,49 @@ export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg
     if (command === "task-supersede") {
         const by = takeOption("--by", "");
         const reason = takeOption("--reason", "");
+        const deletedBy = takeOption("--deleted-by", "");
+        const confirm = takeOption("--confirm", "");
+        const allowOpenFindings = takeFlag("--allow-open-findings");
         const taskId = args.shift();
         if (!taskId) {
             console.error("Missing task id");
             process.exit(2);
         }
         try {
-            console.log(JSON.stringify(supersedeTask(targetArg(), taskId, { by, reason }), null, 2));
+            console.log(JSON.stringify(supersedeTask(targetArg(), taskId, { by, reason, deletedBy, confirm, allowOpenFindings }), null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
     }
     if (["task-delete", "task-archive", "task-reopen"].includes(command)) {
         const soft = takeFlag("--soft");
+        const hard = takeFlag("--hard");
         const reason = takeOption("--reason", "");
+        const deletedBy = command === "task-delete" ? takeOption("--deleted-by", "") : "";
+        const confirm = command === "task-delete" ? takeOption("--confirm", "") : "";
+        const allowOpenFindings = command === "task-delete" ? takeFlag("--allow-open-findings") : false;
+        const archivedBy = command === "task-archive" ? takeOption("--archived-by", "") : "";
+        const archiveFields = command === "task-archive" ? takeRepeatedKeyValueOptions(args, "--archive-field") : {};
         const taskId = args.shift();
         if (!taskId) {
             console.error("Missing task id");
             process.exit(2);
         }
         try {
-            if (command === "task-delete" && !soft)
-                throw new Error("task-delete only supports --soft; hard delete is intentionally disabled.");
+            if (command === "task-delete" && soft && hard)
+                throw new Error("task-delete accepts only one of --soft or --hard");
             const result = command === "task-delete"
-                ? softDeleteTask(targetArg(), taskId, { reason })
+                ? deleteTask(targetArg(), taskId, { hard, reason, deletedBy, confirm, allowOpenFindings })
                 : command === "task-archive"
-                    ? archiveTask(targetArg(), taskId, { reason })
+                    ? archiveTask(targetArg(), taskId, { reason, archivedBy, archiveFields })
                     : reopenTask(targetArg(), taskId, { reason });
             console.log(JSON.stringify(result, null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
@@ -202,14 +207,15 @@ export function runTaskCommand(command, { args, takeFlag, takeOption, targetArg
             console.log(JSON.stringify(updateModuleStep(targetArg(), moduleKey, stepId, { state }), null, 2));
         }
         catch (error) {
-            console.error(error.message);
+            console.error(errorMessage(error));
             process.exit(1);
         }
         return;
     }
     throw new Error(`Unsupported task command: ${command}`);
 }
-function parseNewTaskArgs(args, { preset = "" } = {}) {
+function parseNewTaskArgs(args, { preset = "", fromSession = "" } = {}) {
+    void fromSession;
     const values = [...args];
     const presetPackage = preset ? readPresetPackageForNewTask(preset, values) : null;
     const parsed = splitPresetArgsAndPositionals(values, presetPackage);
@@ -221,6 +227,9 @@ function parseNewTaskArgs(args, { preset = "" } = {}) {
         presetArgs: parsed.presetArgs,
     };
 }
+function invokeCreateTask(target, taskId, options) {
+    return Reflect.apply(createTask, undefined, [target, taskId, options]);
+}
 function readPresetPackageForNewTask(preset, values) {
     const candidates = presetDiscoveryTargetCandidates(values);
     let fallbackPackage = null;
@@ -301,25 +310,73 @@ function resolveNewTaskPositionals(positionals) {
     throw new Error(`Too many positional arguments for new-task: ${positionals.join(", ")}`);
 }
 function formatTaskCommandError(error) {
-    const lines = [error.message];
-    if (Array.isArray(error.recovery) && error.recovery.length > 0) {
+    const recovery = readArrayProperty(error, "recovery");
+    const details = readRecordProperty(error, "details");
+    const lines = [errorMessage(error)];
+    if (recovery.length > 0) {
         lines.push("", "Recovery:");
-        for (const item of error.recovery)
-            lines.push(`- ${item}`);
+        for (const item of recovery)
+            lines.push(`- ${String(item)}`);
     }
-    if (error.details?.entries?.length) {
+    const entries = readArrayProperty(details, "entries");
+    if (entries.length) {
         lines.push("", "Blocking Git status:");
-        for (const entry of error.details.entries)
-            lines.push(`- ${entry.raw || entry.path}`);
+        for (const entry of entries) {
+            const raw = readProperty(entry, "raw");
+            const entryPath = readProperty(entry, "path");
+            lines.push(`- ${String(raw || entryPath || "")}`);
+        }
     }
-    if (error.details?.disallowed?.length) {
+    const disallowed = readArrayProperty(details, "disallowed");
+    if (disallowed.length) {
         lines.push("", "Disallowed paths:");
-        for (const item of error.details.disallowed)
-            lines.push(`- ${item}`);
+        for (const item of disallowed)
+            lines.push(`- ${String(item)}`);
     }
-    if (error.details?.stderr)
-        lines.push("", error.details.stderr);
-    if (error.details?.stdout)
-        lines.push("", error.details.stdout);
+    const stderr = readProperty(details, "stderr");
+    const stdout = readProperty(details, "stdout");
+    if (stderr)
+        lines.push("", String(stderr));
+    if (stdout)
+        lines.push("", String(stdout));
     return lines.join("\n");
 }
+function takeRepeatedKeyValueOptions(args, flag) {
+    const fields = {};
+    for (let index = 0; index < args.length;) {
+        if (args[index] !== flag) {
+            index += 1;
+            continue;
+        }
+        const raw = args[index + 1] || "";
+        args.splice(index, 2);
+        const separator = raw.indexOf("=");
+        if (separator <= 0)
+            throw new Error(`${flag} requires key=value`);
+        const key = raw.slice(0, separator).trim();
+        const value = raw.slice(separator + 1).trim();
+        if (!key || /[\r\n|]/.test(key))
+            throw new Error(`${flag} has invalid field key: ${key || "<empty>"}`);
+        if (Object.prototype.hasOwnProperty.call(fields, key))
+            throw new Error(`${flag} duplicate field key: ${key}`);
+        fields[key] = value;
+    }
+    return fields;
+}
+function readArrayProperty(value, key) {
+    const property = readProperty(value, key);
+    return Array.isArray(property) ? property : [];
+}
+function readRecordProperty(value, key) {
+    const property = readProperty(value, key);
+    return isRecord(property) ? property : null;
+}
+function readProperty(value, key) {
+    return isRecord(value) ? value[key] : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/harness.mjs

@@ -1,305 +1,7 @@
 #!/usr/bin/env node
-// @ts-nocheck
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { createInterface } from "node:readline/promises";
-import { addCapability, buildStatus, doctorUserSkill, installUserSkill, normalizeLocale, rebuildGovernanceIndexes, serveDashboardWorkbench, validateSourcePackageBoundary, writeInitFiles, } from "./lib/harness-core.mjs";
-import { runDashboardCommand } from "./commands/dashboard-command.mjs";
-import { runMigrationCommand } from "./commands/migration-command.mjs";
-import { runPresetCommand } from "./commands/preset-command.mjs";
-import { runTaskCommand } from "./commands/task-command.mjs";
-const args = process.argv.slice(2);
-const command = args.shift() || "help";
-function takeFlag(name, fallback = false) {
-    const index = args.indexOf(name);
-    if (index < 0)
-        return fallback;
-    args.splice(index, 1);
-    return true;
-}
-function takeOption(name, fallback = "") {
-    const index = args.indexOf(name);
-    if (index < 0)
-        return fallback;
-    const value = args[index + 1] || fallback;
-    args.splice(index, 2);
-    return value;
-}
-async function resolveInitLocale(requestedLocale) {
-    if (requestedLocale)
-        return normalizeLocale(requestedLocale);
-    if (!process.stdin.isTTY || !process.stdout.isTTY)
-        return "en-US";
-    const prompt = [
-        "Select harness language / 选择初始化语言:",
-        "  1. 中文 (zh-CN)",
-        "  2. English (en-US)",
-        "Language [1/2, default 2]: ",
-    ].join("\n");
-    const reader = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = (await reader.question(prompt)).trim().toLowerCase();
-        if (["1", "zh", "zh-cn", "cn", "中文"].includes(answer))
-            return "zh-CN";
-        if (["2", "en", "en-us", "english", "英文", ""].includes(answer))
-            return "en-US";
-        console.error(`Unknown language selection: ${answer}. Falling back to en-US.`);
-        return "en-US";
-    }
-    finally {
-        reader.close();
-    }
-}
-async function confirmUserInstall({ yes = false, dryRun = false, agent = "codex" } = {}) {
-    if (yes || dryRun)
-        return true;
-    if (!process.stdin.isTTY || !process.stdout.isTTY)
-        return false;
-    const reader = createInterface({ input: process.stdin, output: process.stdout });
-    try {
-        const answer = (await reader.question(`Install Coding Agent Harness into user skill directory for ${agent}? [y/N] `)).trim().toLowerCase();
-        return ["y", "yes"].includes(answer);
-    }
-    finally {
-        reader.close();
-    }
-}
-function targetArg() {
-    return args[args.length - 1] && !args[args.length - 1].startsWith("-") ? args[args.length - 1] : ".";
-}
-function printHelp() {
-    console.log(`Coding Agent Harness
-
-Usage:
-  harness check [--profile source-package|private-harness|target-project] [target]
-  harness status [--json] [--strict] [target]
-  harness dev [--no-open] [--out-dir folder] [--host 127.0.0.1] [--port n] [target]
-  harness dashboard [--out file.html] [--out-dir folder] [--workbench] [--host 127.0.0.1] [--port n] [target]
-  harness init [--dry-run] [--locale zh-CN|en-US] [--capabilities core,dashboard] [--add-npm-scripts] [target]
-  harness add-capability <name> [--dry-run] [--locale zh-CN|en-US] [target]
-  harness migrate-plan [--json] [--limit n] [target]
-  harness migrate-structure [--plan|--apply] [--force] [--json] [target]
-  harness migrate-task-audit-index [--plan] [--apply] [--json] [target]
-  harness migrate-run [--locale zh-CN|en-US] [--assume-locale] [--allow-dirty] [--plan-only] [--out-dir folder] [--session-dir folder] [target]
-  harness migrate-verify [--json] [--full-cutover] <session.json>
-  harness governance rebuild [--dry-run] [--archive] [--apply] [target]
-  harness preset list [--json] [target]
-  harness preset inspect <id> [--json] [target]
-  harness preset check <id> [--json] [target]
-  harness preset install <folder|zip|builtin-id> [--project] [--force] [--json] [target]
-  harness preset seed [--project] [--force] [--dry-run] [--json] [target]
-  harness preset uninstall <id> [--project] [--json] [target]
-  harness preset run <id> <plan|scaffold|check> --task <task-id> [--json] [target]
-  harness new-task [task-id] [--module key] [--budget simple|standard|complex] [--preset id] [--from-session session.json] [--long-running] [--title title] [--locale zh-CN|en-US] [--dry-run] [target]
-  harness task-start <task-id> [--message text] [target]
-  harness task-phase <task-id> <phase-id> [--state done] [--completion 100] [--evidence present] [target]
-  harness task-log <task-id> --message text [--evidence type:PATH:summary] [target]
-  harness task-block <task-id> [--message text] [target]
-  harness task-review <task-id> [--message text] [target]
-  harness review-confirm <task-id> --confirm task-id [--reviewer name] [--message text] [target]
-  harness lesson-promote <task-id> <candidate-id> [--dry-run|--apply] [target]
-  harness lesson-sediment <task-id> <candidate-id> [--dry-run] [--title title] [target]
-  harness task-complete <task-id> [--message text] [target]
-  harness task-list [--json] [--state state] [--module key] [--queue queue] [--preset id] [--review status] [--lesson status] [--missing-materials] [--include-archived] [--search text] [target]
-  harness task-index [--json] [target]
-  harness task-supersede <old-task-id> --by <new-task-id> [--reason text] [target]
-  harness task-delete <task-id> --soft [--reason text] [target]
-  harness task-archive <task-id> [--reason text] [target]
-  harness task-reopen <task-id> [--reason text] [target]
-  harness module-step <module-key> <step-id> [--state done|in-progress|blocked] [target]
-  harness install-user [--agent codex|claude|gemini|openclaw|agents|all] [--home dir] [--dry-run] [--force] [--skip-presets] [--yes]
-  harness doctor-user [--agent codex|claude|gemini|openclaw|agents|all] [--home dir]
-
-If init runs in an interactive terminal and --locale is omitted, it asks for a
-language. Non-interactive init defaults to en-US.
-
-Preset discovery:
-  Project presets live in <target>/.coding-agent-harness/presets/<preset-id>/.
-  User presets live in ~/.coding-agent-harness/presets/<preset-id>/.
-  Harness discovers project presets first when a target is supplied, then user
-  presets, then bundled package presets under presets/<preset-id>/.
-  "harness init" seeds bundled presets into the target project. "harness
-  install-user" and npm postinstall seed bundled presets into the user root.
-  Use "harness preset seed" to repair or re-run preset seeding.
-  Use "harness preset install" with a local preset folder, .zip archive, or
-  bundled preset id. Preset archives must contain preset.yaml at the archive
-  root or inside one top-level folder.
-  Use "harness preset list --json" to see available presets, their source,
-  purpose, compatible budgets, and manifest path. Use "harness preset inspect
-  <id> --json" for the full preset manifest summary.
-`);
-}
-function exitWithReport(report) {
-    for (const warning of report.warnings || [])
-        console.log(`Warning: ${warning}`);
-    for (const failure of report.failures || [])
-        console.error(`Failure: ${failure}`);
-    process.exit((report.failures || []).length > 0 ? 1 : 0);
-}
-if (command === "help" || command === "--help" || command === "-h") {
-    printHelp();
-}
-else if (args[0] === "help" || args.includes("--help") || args.includes("-h")) {
-    printHelp();
-}
-else if (command === "check") {
-    const profile = takeOption("--profile", "target-project");
-    const strict = takeFlag("--strict");
-    const target = targetArg();
-    const failures = [];
-    const warnings = [];
-    if (profile === "source-package") {
-        for (const required of ["package.json", "dist/harness.mjs", "dist/check-harness.mjs", "templates/planning/task_plan.md"]) {
-            if (!fs.existsSync(path.resolve(target, required)))
-                failures.push(`missing source package file: ${required}`);
-        }
-        const boundary = validateSourcePackageBoundary(target);
-        failures.push(...boundary.failures);
-        warnings.push(...boundary.warnings);
-    }
-    const status = buildStatus(target, { skipLegacyCheck: profile === "source-package", strictLegacy: strict, strict, allowLegacyTarget: profile === "source-package" });
-    failures.push(...status.checkState.details.failures);
-    warnings.push(...status.checkState.details.warnings);
-    if (!["source-package", "private-harness", "target-project"].includes(profile))
-        failures.push(`unknown profile: ${profile}`);
-    if (failures.length === 0)
-        console.log(`Harness check passed (${profile}): ${path.resolve(target)}`);
-    exitWithReport({ failures: [...new Set(failures)], warnings: [...new Set(warnings)] });
-}
-else if (command === "status") {
-    const json = takeFlag("--json");
-    const strict = takeFlag("--strict");
-    const status = buildStatus(targetArg(), { strictLegacy: strict, strict });
-    if (json) {
-        console.log(JSON.stringify(status, null, 2));
-    }
-    else {
-        console.log(`${status.project.name}: ${status.checkState.status} (${status.checkState.failures} failures, ${status.checkState.warnings} warnings)`);
-        console.log(`mode: ${status.mode}`);
-        console.log(`capabilities: ${status.capabilities.map((capability) => `${capability.name}:${capability.state}`).join(", ")}`);
-        console.log(`tasks: ${status.tasks.length}`);
-    }
-    process.exitCode = status.checkState.status === "fail" ? 1 : 0;
-}
-else if (command === "dev") {
-    const open = !takeFlag("--no-open");
-    const outDir = takeOption("--out-dir", "");
-    const host = takeOption("--host", "127.0.0.1");
-    const port = takeOption("--port", "0");
-    const localeOverride = takeOption("--locale", "");
-    const target = targetArg();
-    const usesDefaultOutDir = !outDir;
-    const dashboardOutDir = outDir || defaultDevOutDir(target);
-    const opts = { ...(localeOverride ? { localeOverride } : {}), recoverGeneratedDashboard: usesDefaultOutDir };
-    try {
-        await serveDashboardWorkbench(dashboardOutDir, target, { ...opts, host, port, autoRefresh: true, open, label: "harness dev" });
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-else if (command === "dashboard") {
-    await runDashboardCommand({ takeFlag, takeOption, targetArg });
-}
-else if (command === "init") {
-    const dryRun = takeFlag("--dry-run");
-    const addNpmScripts = takeFlag("--add-npm-scripts");
-    const locale = await resolveInitLocale(takeOption("--locale", ""));
-    const capabilities = takeOption("--capabilities", "core").split(",").map((item) => item.trim()).filter(Boolean);
-    try {
-        const result = writeInitFiles(targetArg(), capabilities, { dryRun, locale, addNpmScripts });
-        console.log(JSON.stringify({ dryRun, locale: result.locale, capabilities: result.capabilities, changes: result.changes, presetSeed: result.presetSeed, nextCommands: result.nextCommands, report: result.report }, null, 2));
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-else if (command === "add-capability") {
-    const dryRun = takeFlag("--dry-run");
-    const locale = normalizeLocale(takeOption("--locale", ""));
-    const capability = args.shift();
-    if (!capability) {
-        console.error("Missing capability name");
-        process.exit(2);
-    }
-    try {
-        const result = addCapability(targetArg(), capability, { dryRun, locale });
-        console.log(JSON.stringify({ dryRun, registry: result.registry, changes: result.changes, report: result.report }, null, 2));
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-else if (["migrate-plan", "migrate-structure", "migrate-run", "migrate-verify", "migrate-task-audit-index"].includes(command)) {
-    runMigrationCommand(command, { args, takeFlag, takeOption, targetArg });
-}
-else if (command === "governance") {
-    const subcommand = args.shift() || "";
-    if (subcommand !== "rebuild") {
-        console.error(`Unknown governance subcommand: ${subcommand || "(missing)"}`);
-        process.exit(2);
-    }
-    const dryRun = takeFlag("--dry-run");
-    const archive = takeFlag("--archive");
-    const apply = takeFlag("--apply");
-    try {
-        console.log(JSON.stringify(rebuildGovernanceIndexes(targetArg(), { dryRun, archive, apply }), null, 2));
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-else if (command === "preset") {
-    runPresetCommand({ args, takeFlag, targetArg });
-}
-else if (["new-task", "task-phase", "task-start", "task-log", "task-block", "task-review", "task-complete", "review-confirm", "lesson-promote", "lesson-sediment", "task-list", "task-index", "task-supersede", "task-delete", "task-archive", "task-reopen", "module-step"].includes(command)) {
-    runTaskCommand(command, { args, takeFlag, takeOption, targetArg });
-}
-else if (command === "install-user") {
-    const dryRun = takeFlag("--dry-run");
-    const force = takeFlag("--force");
-    const yes = takeFlag("--yes") || takeFlag("-y");
-    const skipPresets = takeFlag("--skip-presets");
-    takeFlag("--global");
-    const agent = takeOption("--agent", "codex");
-    const home = takeOption("--home", "");
-    if (!(await confirmUserInstall({ yes, dryRun, agent }))) {
-        console.error("Refusing to write user skill files without confirmation. Re-run with --yes or --dry-run.");
-        process.exit(2);
-    }
-    try {
-        console.log(JSON.stringify(installUserSkill({ agent, home, dryRun, force, seedPresets: !skipPresets }), null, 2));
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-else if (command === "doctor-user") {
-    const agent = takeOption("--agent", "codex");
-    const home = takeOption("--home", "");
-    try {
-        const report = doctorUserSkill({ agent, home });
-        console.log(JSON.stringify(report, null, 2));
-        process.exit(report.status === "pass" ? 0 : 1);
-    }
-    catch (error) {
-        console.error(error.message);
-        process.exit(1);
-    }
-}
-else {
-    printHelp();
-    process.exit(2);
-}
-function defaultDevOutDir(targetInput) {
-    const target = path.resolve(targetInput || ".");
-    const name = path.basename(target) || "project";
-    const hash = Buffer.from(target).toString("hex").slice(0, 16);
-    return path.join(os.tmpdir(), "coding-agent-harness-dev", `${name}-${hash}`);
-}
+import { commandRegistry } from "./commands/registry.mjs";
+import { dispatchCommand } from "./lib/command-registry.mjs";
+await Promise.resolve(dispatchCommand(commandRegistry, process.argv.slice(2))).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});