@cassiomc1/forgeloop 1.14.0 → 2.0.0-rc.4

package/src/cli.js

@@ -4,112 +4,8 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { formatStatusResult } from "./commands/status.js";
-import { formatValidateStateResult } from "./commands/validate-state.js";
-import { formatClearStateResult } from "./commands/clear-state.js";
-import { formatCheckpointRevalidateResult } from "./commands/checkpoint-revalidate.js";
-import { formatInspectResult } from "./commands/inspect.js";
-import { formatRouteResult } from "./commands/route.js";
-import { formatValidateProtocolResult } from "./commands/validate-protocol.js";
-import { formatActivateResult } from "./commands/activate.js";
-import { formatAdvanceResult } from "./commands/advance.js";
-import { formatPreflightResult } from "./commands/preflight.js";
-import { formatQualityBaselineResult } from "./commands/quality-baseline.js";
-import { formatQualityVerifyResult } from "./commands/quality-verify.js";
-import { formatQualityStatusResult } from "./commands/quality-status.js";
-import { formatCompleteResult } from "./commands/complete.js";
-import { formatAuditResult } from "./commands/audit.js";
-import { formatReportResult } from "./commands/report.js";
-import { formatPolicyResult } from "./commands/policy.js";
-import { formatPolicyDiscoverResult } from "./commands/policy-discover.js";
-import { formatPolicyStatusResult } from "./commands/policy-status.js";
-import { formatPolicyDiffResult } from "./commands/policy-diff.js";
-import { formatRuleVerifyResult } from "./commands/rule-verify.js";
-import { formatBaselineResult } from "./commands/baseline.js";
-import { formatProfileInterviewResult } from "./commands/profile-interview.js";
-import { formatBundleResult } from "./commands/bundle.js";
-import { formatPrepareCompletionResult } from "./commands/prepare-completion.js";
-import { formatRecordCheckResult } from "./commands/record-check.js";
-import { formatRunCheckResult } from "./commands/run-check.js";
-import { formatRunActionResult } from "./commands/run-action.js";
-import { formatActionProposeResult } from "./commands/action-propose.js";
-import { formatActionRecordResult } from "./commands/action-record.js";
-import { formatActionAuthorizeResult } from "./commands/action-authorize.js";
-import { formatActionVerifyResult } from "./commands/action-verify.js";
-import { formatActionShowResult } from "./commands/action-show.js";
-import { formatActionReconcileResult } from "./commands/action-reconcile.js";
-import { formatMetricsResult } from "./commands/metrics.js";
-import { formatUsageRecordResult } from "./commands/usage-record.js";
-import { formatEfficiencyResult } from "./commands/efficiency.js";
-import { formatEvalResult } from "./commands/eval.js";
-import { formatApprovalRequestResult } from "./commands/approval-request.js";
-import { formatApprovalResolveResult } from "./commands/approval-resolve.js";
-import { formatReconcileClosureResult } from "./commands/reconcile-closure.js";
-import { formatRecordTerminalResult } from "./commands/record-terminal-result.js";
-import { formatRecordDiagnosisResult } from "./commands/record-diagnosis.js";
-import { formatRecordInterventionResult } from "./commands/record-intervention.js";
-import { formatRecordHypothesisDispositionResult } from "./commands/record-hypothesis-disposition.js";
-import { formatHistoryResult } from "./commands/history.js";
-import { formatTraceResult } from "./commands/trace.js";
-import { formatReflectResult } from "./commands/reflect.js";
-import { formatProgressResult } from "./commands/progress.js";
-import { formatRecordDecisionCriterionResult } from "./commands/record-decision-criterion.js";
-import { formatNextActionResult, formatCompactNextActionResult } from "./commands/next.js";
-import { formatDiscoverResult } from "./commands/discover.js";
-import { formatContractCreateResult } from "./commands/contract-create.js";
-import { formatContractReviseResult } from "./commands/contract-revise.js";
-import { formatContinuityResult } from "./commands/continuity.js";
-import { formatRecordContinuityResult } from "./commands/record-continuity.js";
-import { formatReconcileContinuityResult } from "./commands/reconcile-continuity.js";
-import { formatClearContinuityResult } from "./commands/clear-continuity.js";
-import { formatTaskCreateResult } from "./commands/task-create.js";
-import { formatTaskListResult } from "./commands/task-list.js";
-import { formatTaskShowResult, formatCompactTaskShowResult } from "./commands/task-show.js";
-import { formatTaskScopeResult } from "./commands/task-scope.js";
-import { formatTaskMigrateResult } from "./commands/task-migrate.js";
-import { formatMigrateProtocolResult } from "./commands/migrate-protocol.js";
-import { formatTaskUnlockResult } from "./commands/task-unlock.js";
-import { formatTaskRecoverResult } from "./commands/task-recover.js";
-import { formatTaskAbandonResult } from "./commands/task-abandon.js";
-import { formatTaskResumeResult } from "./commands/task-resume.js";
-import {
-  formatTaskRepairLegacyRecoveryResult,
-} from "./commands/task-repair-legacy-recovery.js";
-import { formatTaskRepairContractBootstrapResult } from "./commands/task-repair-contract-bootstrap.js";
-import { formatTaskMigrateContractBootstrapRepairResult } from "./commands/task-migrate-contract-bootstrap-repair.js";
-import { formatTaskLockStatusResult } from "./commands/task-lock-status.js";
-import { formatProtocolInfoResult } from "./commands/protocol-info.js";
-import { formatWorkspaceBindResult } from "./commands/workspace-bind.js";
-import { formatWorkspaceStatusResult } from "./commands/workspace-status.js";
-import { formatHandoffCreateResult } from "./commands/handoff-create.js";
-import { formatHandoffListResult } from "./commands/handoff-list.js";
-import { formatHandoffShowResult } from "./commands/handoff-show.js";
-import { formatHandoffAcceptResult } from "./commands/handoff-accept.js";
-import { formatResponsibilitySetResult } from "./commands/responsibility-set.js";
-import { formatResponsibilityStatusResult } from "./commands/responsibility-status.js";
-import { formatVerifyScopeResult } from "./commands/verify-scope.js";
-import { formatAttestationCreateResult } from "./commands/attestation-create.js";
-import { formatAttestationVerifyResult } from "./commands/attestation-verify.js";
-import { formatAttestationStatusResult } from "./commands/attestation-status.js";
-import { formatAttestationVerifyRangeResult } from "./commands/attestation-verify-range.js";
-import {
-  formatRepositoryIndexResult,
-  formatRepositoryIndexStatus,
-  formatSearchResult,
-} from "./commands/repository-index.js";
 import { defaultCommandInputValues, validateForgeLoopCommandInput } from "./core/command-input.js";
 import { COMMAND_EXECUTORS } from "./core/command-executors.js";
-import { formatGateRecordResult } from "./commands/gate-record.js";
-import { formatGateRevalidateResult } from "./commands/gate-revalidate.js";
-import { formatDecisionStatusResult } from "./commands/decision-status.js";
-import { formatDecisionShowResult } from "./commands/decision-show.js";
-import { formatContextPlanResult } from "./commands/context-plan.js";
-import { formatModelRouteResult } from "./commands/model-route.js";
-import { formatSemanticPlanResult } from "./commands/semantic-plan.js";
-import { formatTestInventoryResult } from "./commands/test-inventory.js";
-import { formatTestUtilityResult } from "./commands/test-utility.js";
-import { formatTestPrunePlanResult } from "./commands/test-prune-plan.js";
-import { formatTestPruneProbeResult } from "./commands/test-prune-probe.js";
 import { resolveTarget } from "./core/filesystem.js";
 import { getPackageRoot } from "./core/templates.js";
 import { CLI_COMMAND_DEFINITIONS, buildOptionLookup, getPositionalDefinitions } from "./core/cli-command-definitions.js";
@@ -369,77 +265,77 @@ function renderJsonOr(options, result, formatter) {
 export const COMMAND_HANDLERS = Object.freeze({
   discover: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.discover({ target, packageRoot, options });
-    renderJsonOr(options, result, formatDiscoverResult);
+    renderJsonOr(options, result, (await import("./commands/discover.js")).formatDiscoverResult);
     return 0;
   },
   "contract-create": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["contract-create"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatContractCreateResult);
+    renderJsonOr(options, result, (await import("./commands/contract-create.js")).formatContractCreateResult);
     return 0;
   },
   "contract-revise": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["contract-revise"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatContractReviseResult);
+    renderJsonOr(options, result, (await import("./commands/contract-revise.js")).formatContractReviseResult);
     return 0;
   },
   "gate-record": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["gate-record"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatGateRecordResult);
+    renderJsonOr(options, result, (await import("./commands/gate-record.js")).formatGateRecordResult);
     return 0;
   },
   "gate-revalidate": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["gate-revalidate"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatGateRevalidateResult);
+    renderJsonOr(options, result, (await import("./commands/gate-revalidate.js")).formatGateRevalidateResult);
     return 0;
   },
   "protocol-info": async ({ packageVersion, options }) => {
     const { result } = await COMMAND_EXECUTORS["protocol-info"]({ packageVersion, options });
-    renderJsonOr(options, result, formatProtocolInfoResult);
+    renderJsonOr(options, result, (await import("./commands/protocol-info.js")).formatProtocolInfoResult);
     return 0;
   },
   "decision-status": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["decision-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatDecisionStatusResult);
+    renderJsonOr(options, result, (await import("./commands/decision-status.js")).formatDecisionStatusResult);
     return 0;
   },
   "decision-show": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["decision-show"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatDecisionShowResult);
+    renderJsonOr(options, result, (await import("./commands/decision-show.js")).formatDecisionShowResult);
     return 0;
   },
   "context-plan": async ({ options }) => {
     const { result } = await COMMAND_EXECUTORS["context-plan"]({ options });
-    renderJsonOr(options, result, formatContextPlanResult);
+    renderJsonOr(options, result, (await import("./commands/context-plan.js")).formatContextPlanResult);
     return 0;
   },
   "model-route": async ({ options }) => {
     const { result } = await COMMAND_EXECUTORS["model-route"]({ options });
-    renderJsonOr(options, result, formatModelRouteResult);
+    renderJsonOr(options, result, (await import("./commands/model-route.js")).formatModelRouteResult);
     return 0;
   },
   "semantic-plan": async ({ options }) => {
     const { result } = await COMMAND_EXECUTORS["semantic-plan"]({ options });
-    renderJsonOr(options, result, formatSemanticPlanResult);
+    renderJsonOr(options, result, (await import("./commands/semantic-plan.js")).formatSemanticPlanResult);
     return 0;
   },
   "test-inventory": async ({ target, options }) => {
     const { result } = await COMMAND_EXECUTORS["test-inventory"]({ target, options });
-    renderJsonOr(options, result, formatTestInventoryResult);
+    renderJsonOr(options, result, (await import("./commands/test-inventory.js")).formatTestInventoryResult);
     return 0;
   },
   "test-utility": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["test-utility"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTestUtilityResult);
+    renderJsonOr(options, result, (await import("./commands/test-utility.js")).formatTestUtilityResult);
     return 0;
   },
   "test-prune-plan": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["test-prune-plan"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTestPrunePlanResult);
+    renderJsonOr(options, result, (await import("./commands/test-prune-plan.js")).formatTestPrunePlanResult);
     return 0;
   },
   "test-prune-probe": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["test-prune-probe"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTestPruneProbeResult);
+    renderJsonOr(options, result, (await import("./commands/test-prune-probe.js")).formatTestPruneProbeResult);
     return 0;
   },
   init: async ({ target, packageRoot, packageVersion, options }) => {
@@ -447,6 +343,46 @@ export const COMMAND_HANDLERS = Object.freeze({
     printActions(result.actions);
     return 0;
   },
+  "storage-migration-resume": async ({ target, packageRoot, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-migration-resume"]({ target, packageRoot, options });
+    renderJsonOr(options, result, value => `storage recovery: ${value.phase}\ncurrent state verified: ${value.currentStateVerified}`);
+    return exitCode;
+  },
+  "storage-rollback-resume": async ({ target, packageRoot, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-rollback-resume"]({ target, packageRoot, options });
+    renderJsonOr(options, result, value => `source restored: ${value.restored}\ntarget version validated: ${value.targetVersionValidated}`);
+    return exitCode;
+  },
+  "storage-rollback": async ({ target, packageRoot, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-rollback"]({ target, packageRoot, options });
+    renderJsonOr(options, result, value => `source restored: ${value.restored}\ntarget version validated: ${value.targetVersionValidated}`);
+    return exitCode;
+  },
+  "storage-migrate": async ({ target, packageRoot, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-migrate"]({ target, packageRoot, options });
+    renderJsonOr(options, result, value => `storage migration: ${value.phase}\ncurrent state verified: ${value.currentStateVerified}`);
+    return exitCode;
+  },
+  "storage-backup": async ({ target, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-backup"]({ target, options });
+    renderJsonOr(options, result, value => `storage backup: ${value.path}\nattachments included: ${value.attachmentsIncluded}`);
+    return exitCode;
+  },
+  "storage-restore": async ({ target, packageRoot, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-restore"]({ target, packageRoot, options });
+    renderJsonOr(options, result, value => `storage restore: ${value.path}\nactive: ${value.active}\nretained snapshot: ${value.retainedSnapshot}`);
+    return exitCode;
+  },
+  "storage-restore-resume": async ({ target, packageRoot, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-restore-resume"]({ target, packageRoot, options });
+    renderJsonOr(options, result, value => `restore recovery: ${value.active ? "ACTIVE" : "incomplete"}\nrestored snapshot: ${value.restored}\ncurrent state verified: ${value.currentStateVerified ?? false}`);
+    return exitCode;
+  },
+  "storage-migration-status": async ({ target, options }) => {
+    const { result, exitCode } = await COMMAND_EXECUTORS["storage-migration-status"]({ target, options });
+    renderJsonOr(options, result, value => `storage layout: ${value.layout}\nmaintenance: ${value.maintenance.status}`);
+    return exitCode;
+  },
   doctor: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.doctor({ target, packageRoot, options });
     if (options.json) {
@@ -463,240 +399,240 @@ export const COMMAND_HANDLERS = Object.freeze({
   },
   "index-setup": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["index-setup"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRepositoryIndexResult);
+    renderJsonOr(options, result, (await import("./commands/repository-index.js")).formatRepositoryIndexResult);
     return 0;
   },
   "index-start": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["index-start"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRepositoryIndexResult);
+    renderJsonOr(options, result, (await import("./commands/repository-index.js")).formatRepositoryIndexResult);
     return 0;
   },
   "index-stop": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["index-stop"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRepositoryIndexResult);
+    renderJsonOr(options, result, (await import("./commands/repository-index.js")).formatRepositoryIndexResult);
     return 0;
   },
   "index-status": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["index-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRepositoryIndexStatus);
+    renderJsonOr(options, result, (await import("./commands/repository-index.js")).formatRepositoryIndexStatus);
     return 0;
   },
   "index-rebuild": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["index-rebuild"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRepositoryIndexResult);
+    renderJsonOr(options, result, (await import("./commands/repository-index.js")).formatRepositoryIndexResult);
     return 0;
   },
   search: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.search({ target, packageRoot, options, transport: "cli" });
-    renderJsonOr(options, result, formatSearchResult);
+    renderJsonOr(options, result, (await import("./commands/repository-index.js")).formatSearchResult);
     return exitCode;
   },
   route: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.route({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRouteResult);
+    renderJsonOr(options, result, (await import("./commands/route.js")).formatRouteResult);
     return 0;
   },
   activate: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.activate({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActivateResult);
+    renderJsonOr(options, result, (await import("./commands/activate.js")).formatActivateResult);
     return 0;
   },
   preflight: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.preflight({ target, packageRoot, options });
-    renderJsonOr(options, result, formatPreflightResult);
+    renderJsonOr(options, result, (await import("./commands/preflight.js")).formatPreflightResult);
     return exitCode;
   },
   "quality-baseline": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["quality-baseline"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatQualityBaselineResult);
+    renderJsonOr(options, result, (await import("./commands/quality-baseline.js")).formatQualityBaselineResult);
     return exitCode;
   },
   "quality-verify": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["quality-verify"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatQualityVerifyResult);
+    renderJsonOr(options, result, (await import("./commands/quality-verify.js")).formatQualityVerifyResult);
     return exitCode;
   },
   "quality-status": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["quality-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatQualityStatusResult);
+    renderJsonOr(options, result, (await import("./commands/quality-status.js")).formatQualityStatusResult);
     return exitCode;
   },
   advance: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.advance({ target, packageRoot, options });
-    renderJsonOr(options, result, formatAdvanceResult);
+    renderJsonOr(options, result, (await import("./commands/advance.js")).formatAdvanceResult);
     return 0;
   },
   next: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.next({ target, packageRoot, options });
-    if (options.compact) console.log(formatCompactNextActionResult(result));
-    else renderJsonOr(options, result, formatNextActionResult);
+    if (options.compact) console.log((await import("./commands/next.js")).formatCompactNextActionResult(result));
+    else renderJsonOr(options, result, (await import("./commands/next.js")).formatNextActionResult);
     return 0;
   },
   continuity: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.continuity({ target, packageRoot, options });
-    renderJsonOr(options, result, formatContinuityResult);
+    renderJsonOr(options, result, (await import("./commands/continuity.js")).formatContinuityResult);
     return 0;
   },
   "record-continuity": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-continuity"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordContinuityResult);
+    renderJsonOr(options, result, (await import("./commands/record-continuity.js")).formatRecordContinuityResult);
     return 0;
   },
   "reconcile-continuity": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["reconcile-continuity"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatReconcileContinuityResult);
+    renderJsonOr(options, result, (await import("./commands/reconcile-continuity.js")).formatReconcileContinuityResult);
     return 0;
   },
   "clear-continuity": async ({ target, options }) => {
     const { result } = await COMMAND_EXECUTORS["clear-continuity"]({ target, options });
-    renderJsonOr(options, result, formatClearContinuityResult);
+    renderJsonOr(options, result, (await import("./commands/clear-continuity.js")).formatClearContinuityResult);
     return 0;
   },
   "prepare-completion": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["prepare-completion"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatPrepareCompletionResult);
+    renderJsonOr(options, result, (await import("./commands/prepare-completion.js")).formatPrepareCompletionResult);
     return 0;
   },
   "run-check": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["run-check"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRunCheckResult);
+    renderJsonOr(options, result, (await import("./commands/run-check.js")).formatRunCheckResult);
     return exitCode;
   },
   "workspace-bind": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["workspace-bind"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatWorkspaceBindResult);
+    renderJsonOr(options, result, (await import("./commands/workspace-bind.js")).formatWorkspaceBindResult);
     return exitCode;
   },
   "workspace-status": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["workspace-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatWorkspaceStatusResult);
+    renderJsonOr(options, result, (await import("./commands/workspace-status.js")).formatWorkspaceStatusResult);
     return exitCode;
   },
   "handoff-create": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["handoff-create"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatHandoffCreateResult);
+    renderJsonOr(options, result, (await import("./commands/handoff-create.js")).formatHandoffCreateResult);
     return exitCode;
   },
   "handoff-list": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["handoff-list"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatHandoffListResult);
+    renderJsonOr(options, result, (await import("./commands/handoff-list.js")).formatHandoffListResult);
     return exitCode;
   },
   "handoff-show": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["handoff-show"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatHandoffShowResult);
+    renderJsonOr(options, result, (await import("./commands/handoff-show.js")).formatHandoffShowResult);
     return exitCode;
   },
   "handoff-accept": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["handoff-accept"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatHandoffAcceptResult);
+    renderJsonOr(options, result, (await import("./commands/handoff-accept.js")).formatHandoffAcceptResult);
     return exitCode;
   },
   "responsibility-set": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["responsibility-set"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatResponsibilitySetResult);
+    renderJsonOr(options, result, (await import("./commands/responsibility-set.js")).formatResponsibilitySetResult);
     return exitCode;
   },
   "responsibility-status": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["responsibility-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatResponsibilityStatusResult);
+    renderJsonOr(options, result, (await import("./commands/responsibility-status.js")).formatResponsibilityStatusResult);
     return exitCode;
   },
   "verify-scope": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["verify-scope"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatVerifyScopeResult);
+    renderJsonOr(options, result, (await import("./commands/verify-scope.js")).formatVerifyScopeResult);
     return exitCode;
   },
   "attestation-create": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["attestation-create"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatAttestationCreateResult);
+    renderJsonOr(options, result, (await import("./commands/attestation-create.js")).formatAttestationCreateResult);
     return exitCode;
   },
   "attestation-verify": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["attestation-verify"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatAttestationVerifyResult);
+    renderJsonOr(options, result, (await import("./commands/attestation-verify.js")).formatAttestationVerifyResult);
     return exitCode;
   },
   "attestation-status": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["attestation-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatAttestationStatusResult);
+    renderJsonOr(options, result, (await import("./commands/attestation-status.js")).formatAttestationStatusResult);
     return exitCode;
   },
   "attestation-verify-range": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["attestation-verify-range"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatAttestationVerifyRangeResult);
+    renderJsonOr(options, result, (await import("./commands/attestation-verify-range.js")).formatAttestationVerifyRangeResult);
     return exitCode;
   },
   "run-action": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["run-action"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRunActionResult);
+    renderJsonOr(options, result, (await import("./commands/run-action.js")).formatRunActionResult);
     return exitCode;
   },
   "action-propose": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["action-propose"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActionProposeResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/action-propose.js")).formatActionProposeResult); return 0;
   },
   "action-authorize": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["action-authorize"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActionAuthorizeResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/action-authorize.js")).formatActionAuthorizeResult); return 0;
   },
   "action-record": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["action-record"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActionRecordResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/action-record.js")).formatActionRecordResult); return 0;
   },
   "action-verify": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["action-verify"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActionVerifyResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/action-verify.js")).formatActionVerifyResult); return 0;
   },
   "action-show": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["action-show"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActionShowResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/action-show.js")).formatActionShowResult); return 0;
   },
   "action-reconcile": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["action-reconcile"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatActionReconcileResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/action-reconcile.js")).formatActionReconcileResult); return 0;
   },
   metrics: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.metrics({ target, packageRoot, options });
-    renderJsonOr(options, result, formatMetricsResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/metrics.js")).formatMetricsResult); return 0;
   },
   "usage-record": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["usage-record"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatUsageRecordResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/usage-record.js")).formatUsageRecordResult); return 0;
   },
   efficiency: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.efficiency({ target, packageRoot, options });
-    renderJsonOr(options, result, formatEfficiencyResult); return 0;
+    renderJsonOr(options, result, (await import("./commands/efficiency.js")).formatEfficiencyResult); return 0;
   },
   eval: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.eval({ target, packageRoot, options });
-    renderJsonOr(options, result, formatEvalResult); return exitCode;
+    renderJsonOr(options, result, (await import("./commands/eval.js")).formatEvalResult); return exitCode;
   },
-  "approval-request": async ({ target, packageRoot, options }) => { const { result } = await COMMAND_EXECUTORS["approval-request"]({ target, packageRoot, options }); renderJsonOr(options, result, formatApprovalRequestResult); return 0; },
-  "approval-resolve": async ({ target, packageRoot, options }) => { const { result } = await COMMAND_EXECUTORS["approval-resolve"]({ target, packageRoot, options }); renderJsonOr(options, result, formatApprovalResolveResult); return 0; },
+  "approval-request": async ({ target, packageRoot, options }) => { const { result } = await COMMAND_EXECUTORS["approval-request"]({ target, packageRoot, options }); renderJsonOr(options, result, (await import("./commands/approval-request.js")).formatApprovalRequestResult); return 0; },
+  "approval-resolve": async ({ target, packageRoot, options }) => { const { result } = await COMMAND_EXECUTORS["approval-resolve"]({ target, packageRoot, options }); renderJsonOr(options, result, (await import("./commands/approval-resolve.js")).formatApprovalResolveResult); return 0; },
   "record-check": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-check"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordCheckResult);
+    renderJsonOr(options, result, (await import("./commands/record-check.js")).formatRecordCheckResult);
     return 0;
   },
   "record-terminal-result": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-terminal-result"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordTerminalResult);
+    renderJsonOr(options, result, (await import("./commands/record-terminal-result.js")).formatRecordTerminalResult);
     return 0;
   },
   "record-diagnosis": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-diagnosis"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordDiagnosisResult);
+    renderJsonOr(options, result, (await import("./commands/record-diagnosis.js")).formatRecordDiagnosisResult);
     return 0;
   },
   "record-intervention": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-intervention"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordInterventionResult);
+    renderJsonOr(options, result, (await import("./commands/record-intervention.js")).formatRecordInterventionResult);
     return 0;
   },
   "record-hypothesis-disposition": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-hypothesis-disposition"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordHypothesisDispositionResult);
+    renderJsonOr(options, result, (await import("./commands/record-hypothesis-disposition.js")).formatRecordHypothesisDispositionResult);
     return 0;
   },
   history: async ({ target, packageRoot, options }) => {
@@ -708,94 +644,94 @@ export const COMMAND_HANDLERS = Object.freeze({
         console.log(`${event.timestamp ?? "--:--:--"} ${event.type}`);
       }
     } else if (options.verbose) {
-      console.log(formatHistoryResult(result));
+      console.log((await import("./commands/history.js")).formatHistoryResult(result));
       for (const event of result.events) {
         console.log(`--- ${event.sequence} ${event.type} ---`);
         console.log(JSON.stringify(event.data, null, 2));
       }
     } else {
-      console.log(formatHistoryResult(result));
+      console.log((await import("./commands/history.js")).formatHistoryResult(result));
     }
     return exitCode;
   },
   trace: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.trace({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTraceResult);
+    renderJsonOr(options, result, (await import("./commands/trace.js")).formatTraceResult);
     return exitCode;
   },
   reflect: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.reflect({ target, packageRoot, options });
-    renderJsonOr(options, result, formatReflectResult);
+    renderJsonOr(options, result, (await import("./commands/reflect.js")).formatReflectResult);
     return exitCode;
   },
   progress: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.progress({ target, packageRoot, options });
-    renderJsonOr(options, result, formatProgressResult);
+    renderJsonOr(options, result, (await import("./commands/progress.js")).formatProgressResult);
     return exitCode;
   },
   "record-decision-criterion": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["record-decision-criterion"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRecordDecisionCriterionResult);
+    renderJsonOr(options, result, (await import("./commands/record-decision-criterion.js")).formatRecordDecisionCriterionResult);
     return 0;
   },
   complete: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.complete({ target, packageRoot, options });
-    renderJsonOr(options, result, formatCompleteResult);
+    renderJsonOr(options, result, (await import("./commands/complete.js")).formatCompleteResult);
     return exitCode;
   },
   audit: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.audit({ target, packageRoot, options });
-    renderJsonOr(options, result, formatAuditResult);
+    renderJsonOr(options, result, (await import("./commands/audit.js")).formatAuditResult);
     return exitCode;
   },
   report: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.report({ target, packageRoot, options });
-    renderJsonOr(options, result, formatReportResult);
+    renderJsonOr(options, result, (await import("./commands/report.js")).formatReportResult);
     return exitCode;
   },
   policy: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.policy({ target, packageRoot, options });
-    renderJsonOr(options, result, formatPolicyResult);
+    renderJsonOr(options, result, (await import("./commands/policy.js")).formatPolicyResult);
     return 0;
   },
   "policy-discover": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["policy-discover"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatPolicyDiscoverResult);
+    renderJsonOr(options, result, (await import("./commands/policy-discover.js")).formatPolicyDiscoverResult);
     return 0;
   },
   "policy-status": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["policy-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatPolicyStatusResult);
+    renderJsonOr(options, result, (await import("./commands/policy-status.js")).formatPolicyStatusResult);
     return exitCode;
   },
   "policy-diff": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["policy-diff"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatPolicyDiffResult);
+    renderJsonOr(options, result, (await import("./commands/policy-diff.js")).formatPolicyDiffResult);
     return 0;
   },
   "rule-verify": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["rule-verify"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatRuleVerifyResult);
+    renderJsonOr(options, result, (await import("./commands/rule-verify.js")).formatRuleVerifyResult);
     return exitCode;
   },
   baseline: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.baseline({ target, packageRoot, options });
-    renderJsonOr(options, result, formatBaselineResult);
+    renderJsonOr(options, result, (await import("./commands/baseline.js")).formatBaselineResult);
     return 0;
   },
   "profile-interview": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["profile-interview"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatProfileInterviewResult);
+    renderJsonOr(options, result, (await import("./commands/profile-interview.js")).formatProfileInterviewResult);
     return 0;
   },
   bundle: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.bundle({ target, packageRoot, options });
-    renderJsonOr(options, result, formatBundleResult);
+    renderJsonOr(options, result, (await import("./commands/bundle.js")).formatBundleResult);
     return 0;
   },
   inspect: async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS.inspect({ target, packageRoot, options });
-    renderJsonOr(options, result, formatInspectResult);
+    renderJsonOr(options, result, (await import("./commands/inspect.js")).formatInspectResult);
     return exitCode;
   },
   "validate-receipt": async ({ target, packageRoot, options }) => {
@@ -805,63 +741,63 @@ export const COMMAND_HANDLERS = Object.freeze({
   },
   "validate-protocol": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["validate-protocol"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatValidateProtocolResult);
+    renderJsonOr(options, result, (await import("./commands/validate-protocol.js")).formatValidateProtocolResult);
     return exitCode;
   },
   status: async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS.status({ target, packageRoot, options });
-    renderJsonOr(options, result, formatStatusResult);
+    renderJsonOr(options, result, (await import("./commands/status.js")).formatStatusResult);
     return 0;
   },
   "validate-state": async ({ target, packageRoot, options }) => {
     const { result, exitCode } = await COMMAND_EXECUTORS["validate-state"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatValidateStateResult);
+    renderJsonOr(options, result, (await import("./commands/validate-state.js")).formatValidateStateResult);
     return exitCode;
   },
   "clear-state": async ({ target, options }) => {
     const { result } = await COMMAND_EXECUTORS["clear-state"]({ target, options });
-    renderJsonOr(options, result, formatClearStateResult);
+    renderJsonOr(options, result, (await import("./commands/clear-state.js")).formatClearStateResult);
     return 0;
   },
   "task-create": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-create"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskCreateResult);
+    renderJsonOr(options, result, (await import("./commands/task-create.js")).formatTaskCreateResult);
     return 0;
   },
   "task-list": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-list"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskListResult);
+    renderJsonOr(options, result, (await import("./commands/task-list.js")).formatTaskListResult);
     return 0;
   },
   "task-show": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-show"]({ target, packageRoot, options });
-    if (options.compact) console.log(formatCompactTaskShowResult(result));
-    else renderJsonOr(options, result, formatTaskShowResult);
+    if (options.compact) console.log((await import("./commands/task-show.js")).formatCompactTaskShowResult(result));
+    else renderJsonOr(options, result, (await import("./commands/task-show.js")).formatTaskShowResult);
     return 0;
   },
   "task-lock-status": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-lock-status"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskLockStatusResult);
+    renderJsonOr(options, result, (await import("./commands/task-lock-status.js")).formatTaskLockStatusResult);
     return 0;
   },
   "task-scope": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-scope"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskScopeResult);
+    renderJsonOr(options, result, (await import("./commands/task-scope.js")).formatTaskScopeResult);
     return 0;
   },
   "task-migrate": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-migrate"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskMigrateResult);
+    renderJsonOr(options, result, (await import("./commands/task-migrate.js")).formatTaskMigrateResult);
     return 0;
   },
   "migrate-protocol": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["migrate-protocol"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatMigrateProtocolResult);
+    renderJsonOr(options, result, (await import("./commands/migrate-protocol.js")).formatMigrateProtocolResult);
     return 0;
   },
   "task-unlock": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-unlock"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskUnlockResult);
+    renderJsonOr(options, result, (await import("./commands/task-unlock.js")).formatTaskUnlockResult);
     return 0;
   },
   "task-recover": async ({ target, packageRoot, options }) => {
@@ -869,42 +805,42 @@ export const COMMAND_HANDLERS = Object.freeze({
       console.error("DEPRECATION: --operator-authorized is caller acknowledgement, not host attestation; use --acknowledge-recovery.");
     }
     const { result } = await COMMAND_EXECUTORS["task-recover"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskRecoverResult);
+    renderJsonOr(options, result, (await import("./commands/task-recover.js")).formatTaskRecoverResult);
     return 0;
   },
   "task-abandon": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-abandon"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskAbandonResult);
+    renderJsonOr(options, result, (await import("./commands/task-abandon.js")).formatTaskAbandonResult);
     return 0;
   },
   "task-resume": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-resume"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskResumeResult);
+    renderJsonOr(options, result, (await import("./commands/task-resume.js")).formatTaskResumeResult);
     return 0;
   },
   "task-repair-contract-bootstrap": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-repair-contract-bootstrap"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskRepairContractBootstrapResult);
+    renderJsonOr(options, result, (await import("./commands/task-repair-contract-bootstrap.js")).formatTaskRepairContractBootstrapResult);
     return 0;
   },
   "task-migrate-contract-bootstrap-repair": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-migrate-contract-bootstrap-repair"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskMigrateContractBootstrapRepairResult);
+    renderJsonOr(options, result, (await import("./commands/task-migrate-contract-bootstrap-repair.js")).formatTaskMigrateContractBootstrapRepairResult);
     return 0;
   },
   "checkpoint-revalidate": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["checkpoint-revalidate"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatCheckpointRevalidateResult);
+    renderJsonOr(options, result, (await import("./commands/checkpoint-revalidate.js")).formatCheckpointRevalidateResult);
     return 0;
   },
   "task-repair-legacy-recovery": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["task-repair-legacy-recovery"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatTaskRepairLegacyRecoveryResult);
+    renderJsonOr(options, result, (await import("./commands/task-repair-legacy-recovery.js")).formatTaskRepairLegacyRecoveryResult);
     return 0;
   },
   "reconcile-closure": async ({ target, packageRoot, options }) => {
     const { result } = await COMMAND_EXECUTORS["reconcile-closure"]({ target, packageRoot, options });
-    renderJsonOr(options, result, formatReconcileClosureResult);
+    renderJsonOr(options, result, (await import("./commands/reconcile-closure.js")).formatReconcileClosureResult);
     return 0;
   },
   update: async ({ target, packageRoot, packageVersion, options }) => {