agentplane 0.3.14 → 0.3.16

package/dist/cli/run-cli/command-catalog/core.js

@@ -20,100 +20,58 @@ import { roleSpec } from "../commands/core/role.js";
 import { ideSyncSpec } from "../commands/ide.js";
 import { initSpec } from "../commands/init.js";
 import { requireCanonicalCommandInvocation } from "../../command-invocations.js";
-import { entry } from "./shared.js";
+import { declareCommand } from "./shared.js";
+import { fromCommandsInit, fromCommandsUpgradeCommand, fromCommandsReleaseReleaseCommand, fromCommandsReleasePlanCommand, fromCommandsReleaseApplyCommand, fromCommandsCoreQuickstart, fromCommandsCorePreflight, fromCommandsCodex, fromCommandsRuntimeCommand, fromCommandsIncidentsIncidentsCommand, fromCommandsCoreRole, fromCommandsDoctorRun, fromCommandsWorkflowCommand, fromCommandsWorkflowBuildCommand, fromCommandsWorkflowRestoreCommand, fromCommandsWorkflowPlaybookCommand, loadCodexPluginInstallSpec, loadIncidentsCollectSpec, loadIncidentsAdviseSpec, loadAgentsSpec, loadConfigShowSpec, loadConfigSetSpec, loadModeGetSpec, loadModeSetSpec, loadProfileSetSpec, loadIdeSyncSpec, } from "../command-loaders.js";
 export const CORE_COMMANDS = [
-    entry(initSpec, () => import("../commands/init.js").then((m) => m.runInit), {
+    fromCommandsInit(initSpec, "runInit", {
         needs: "none",
         invocation: requireCanonicalCommandInvocation(["init"]),
     }),
-    entry(upgradeSpec, () => import("../../../commands/upgrade.command.js").then((m) => m.runUpgrade), {
-        needs: "none",
-    }),
-    entry(releaseSpec, () => import("../../../commands/release/release.command.js").then((m) => m.runRelease), {
-        needs: "none",
-    }),
-    entry(releasePlanSpec, () => import("../../../commands/release/plan.command.js").then((m) => m.runReleasePlan), {
-        needs: "project",
-    }),
-    entry(releaseApplySpec, () => import("../../../commands/release/apply.command.js").then((m) => m.runReleaseApply), {
+    fromCommandsUpgradeCommand(upgradeSpec, "runUpgrade", { needs: "none" }),
+    fromCommandsReleaseReleaseCommand(releaseSpec, "runRelease", { needs: "none" }),
+    fromCommandsReleasePlanCommand(releasePlanSpec, "runReleasePlan", { needs: "project" }),
+    fromCommandsReleaseApplyCommand(releaseApplySpec, "runReleaseApply", { needs: "project" }),
+    fromCommandsReleaseApplyCommand(releaseCandidateSpec, "runReleaseCandidate", {
         needs: "project",
     }),
-    entry(releaseCandidateSpec, () => import("../../../commands/release/apply.command.js").then((m) => m.runReleaseCandidate), {
-        needs: "project",
-    }),
-    entry(quickstartSpec, () => import("../commands/core/quickstart.js").then((m) => m.runQuickstart), {
+    fromCommandsCoreQuickstart(quickstartSpec, "runQuickstart", {
         needs: "none",
         invocation: requireCanonicalCommandInvocation(["quickstart"]),
     }),
-    entry(preflightSpec, () => import("../commands/core/preflight.js").then((m) => m.runPreflight), {
+    fromCommandsCorePreflight(preflightSpec, "runPreflight", {
         needs: "none",
         invocation: requireCanonicalCommandInvocation(["preflight"]),
     }),
-    entry(codexSpec, () => import("../commands/codex.js").then((m) => m.runCodex), {
-        needs: "none",
-    }),
-    entry(codexPluginSpec, () => import("../commands/codex.js").then((m) => m.runCodexPlugin), {
-        needs: "none",
-    }),
-    entry(codexPluginInstallSpec, (deps) => import("../commands/codex.js").then((m) => m.makeRunCodexPluginInstallHandler(deps)), {
-        needs: "none",
-    }),
-    entry(runtimeSpec, () => import("../../../commands/runtime.command.js").then((m) => m.runRuntime), {
-        needs: "none",
-    }),
-    entry(runtimeExplainSpec, () => import("../../../commands/runtime.command.js").then((m) => m.runRuntimeExplain), {
-        needs: "none",
-    }),
-    entry(incidentsSpec, () => import("../../../commands/incidents/incidents.command.js").then((m) => m.runIncidents), {
-        needs: "none",
-    }),
-    entry(incidentsCollectSpec, (deps) => import("../../../commands/incidents/collect.command.js").then((m) => m.makeRunIncidentsCollectHandler(deps.getCtx))),
-    entry(incidentsAdviseSpec, (deps) => import("../../../commands/incidents/advise.command.js").then((m) => m.makeRunIncidentsAdviseHandler(deps.getCtx))),
-    entry(roleSpec, () => import("../commands/core/role.js").then((m) => m.runRole), {
+    fromCommandsCodex(codexSpec, "runCodex", { needs: "none" }),
+    fromCommandsCodex(codexPluginSpec, "runCodexPlugin", { needs: "none" }),
+    declareCommand(codexPluginInstallSpec, { load: loadCodexPluginInstallSpec, needs: "none" }),
+    fromCommandsRuntimeCommand(runtimeSpec, "runRuntime", { needs: "none" }),
+    fromCommandsRuntimeCommand(runtimeExplainSpec, "runRuntimeExplain", { needs: "none" }),
+    fromCommandsIncidentsIncidentsCommand(incidentsSpec, "runIncidents", { needs: "none" }),
+    declareCommand(incidentsCollectSpec, { load: loadIncidentsCollectSpec }),
+    declareCommand(incidentsAdviseSpec, { load: loadIncidentsAdviseSpec }),
+    fromCommandsCoreRole(roleSpec, "runRole", {
         needs: "none",
         invocation: requireCanonicalCommandInvocation(["role"]),
     }),
-    entry(agentsSpec, (deps) => import("../commands/core/agents.js").then((m) => m.makeRunAgentsHandler(deps)), {
-        needs: "project",
-    }),
-    entry(configShowSpec, (deps) => import("../commands/config.js").then((m) => m.makeRunConfigShowHandler(deps)), {
+    declareCommand(agentsSpec, { load: loadAgentsSpec, needs: "project" }),
+    declareCommand(configShowSpec, {
+        load: loadConfigShowSpec,
         needs: "project+config",
         invocation: requireCanonicalCommandInvocation(["config", "show"]),
     }),
-    entry(configSetSpec, (deps) => import("../commands/config.js").then((m) => m.makeRunConfigSetHandler(deps)), {
-        needs: "project+config",
-    }),
-    entry(modeGetSpec, (deps) => import("../commands/config.js").then((m) => m.makeRunModeGetHandler(deps)), {
-        needs: "project+config",
-    }),
-    entry(modeSetSpec, (deps) => import("../commands/config.js").then((m) => m.makeRunModeSetHandler(deps)), {
-        needs: "project+config",
-    }),
-    entry(profileSetSpec, (deps) => import("../commands/config.js").then((m) => m.makeRunProfileSetHandler(deps)), {
-        needs: "project+config",
-    }),
-    entry(ideSyncSpec, (deps) => import("../commands/ide.js").then((m) => m.makeRunIdeSyncHandler(deps)), {
-        needs: "project",
-    }),
-    entry(doctorSpec, () => import("../../../commands/doctor.run.js").then((m) => m.runDoctor), {
-        needs: "project",
-    }),
-    entry(workflowSpec, () => import("../../../commands/workflow.command.js").then((m) => m.runWorkflow), {
-        needs: "none",
-    }),
-    entry(workflowBuildSpec, () => import("../../../commands/workflow-build.command.js").then((m) => m.runWorkflowBuild), {
-        needs: "project",
-    }),
-    entry(workflowRestoreSpec, () => import("../../../commands/workflow-restore.command.js").then((m) => m.runWorkflowRestore), {
-        needs: "project",
-    }),
-    entry(workflowDebugSpec, () => import("../../../commands/workflow-playbook.command.js").then((m) => m.runWorkflowDebug), {
-        needs: "project",
-    }),
-    entry(workflowSyncSpec, () => import("../../../commands/workflow-playbook.command.js").then((m) => m.runWorkflowSync), {
-        needs: "project",
-    }),
-    entry(workflowLandSpec, () => import("../../../commands/workflow-playbook.command.js").then((m) => m.runWorkflowLand), {
+    declareCommand(configSetSpec, { load: loadConfigSetSpec, needs: "project+config" }),
+    declareCommand(modeGetSpec, { load: loadModeGetSpec, needs: "project+config" }),
+    declareCommand(modeSetSpec, { load: loadModeSetSpec, needs: "project+config" }),
+    declareCommand(profileSetSpec, { load: loadProfileSetSpec, needs: "project+config" }),
+    declareCommand(ideSyncSpec, { load: loadIdeSyncSpec, needs: "project" }),
+    fromCommandsDoctorRun(doctorSpec, "runDoctor", { needs: "project" }),
+    fromCommandsWorkflowCommand(workflowSpec, "runWorkflow", { needs: "none" }),
+    fromCommandsWorkflowBuildCommand(workflowBuildSpec, "runWorkflowBuild", { needs: "project" }),
+    fromCommandsWorkflowRestoreCommand(workflowRestoreSpec, "runWorkflowRestore", {
         needs: "project",
     }),
+    fromCommandsWorkflowPlaybookCommand(workflowDebugSpec, "runWorkflowDebug", { needs: "project" }),
+    fromCommandsWorkflowPlaybookCommand(workflowSyncSpec, "runWorkflowSync", { needs: "project" }),
+    fromCommandsWorkflowPlaybookCommand(workflowLandSpec, "runWorkflowLand", { needs: "project" }),
 ];

package/dist/cli/run-cli/command-catalog/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/lifecycle.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,kBAAkB,yPAmFa,CAAC"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/lifecycle.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAqBhE,eAAO,MAAM,kBAAkB,yPAwBa,CAAC"}

package/dist/cli/run-cli/command-catalog/lifecycle.js

@@ -15,33 +15,30 @@ import { readySpec } from "../../../commands/ready.command.js";
 import { startSpec } from "../../../commands/start.spec.js";
 import { verifySpec } from "../../../commands/verify.spec.js";
 import { requireCanonicalCommandInvocation } from "../../command-invocations.js";
-import { entry } from "./shared.js";
+import { declareCommand } from "./shared.js";
+import { fromCommandsHooksHooksCommand, fromCommandsHooksInstallCommand, fromCommandsHooksRunCommand, fromCommandsGuardGuardCommand, fromCommandsGuardCleanCommand, loadCommitSpec, loadStartSpec, loadBlockSpec, loadVerifySpec, loadFinishSpec, loadReadySpec, loadDocsCliSpec, fromHooksUninstallSpec, fromCleanupSpec, loadCleanupMergedSpec, fromGuardSuggestAllowSpec, loadGuardCommitSpec, } from "../command-loaders.js";
 export const LIFECYCLE_COMMANDS = [
-    entry(commitSpec, (deps) => import("../../../commands/commit.command.js").then((m) => m.makeRunCommitHandler(deps.getCtx))),
-    entry(startSpec, (deps) => import("../../../commands/start.run.js").then((m) => m.makeRunStartHandler(deps.getCtx))),
-    entry(blockSpec, (deps) => import("../../../commands/block.run.js").then((m) => m.makeRunBlockHandler(deps.getCtx))),
-    entry(verifySpec, (deps) => import("../../../commands/verify.run.js").then((m) => m.makeRunVerifyHandler(deps.getCtx)), { invocation: requireCanonicalCommandInvocation(["verify"]) }),
-    entry(finishSpec, (deps) => import("../../../commands/finish.run.js").then((m) => m.makeRunFinishHandler(deps.getCtx)), {
-        invocation: requireCanonicalCommandInvocation(["finish"]),
-    }),
-    entry(readySpec, (deps) => import("../../../commands/ready.command.js").then((m) => m.makeRunReadyHandler(deps.getCtx))),
-    entry(docsCliSpec, (deps) => import("../../../commands/docs/cli.command.js").then((m) => m.makeRunDocsCliHandler(deps.getHelpJsonForDocs)), {
-        needs: "none",
-    }),
-    entry(hooksSpec, () => import("../../../commands/hooks/hooks.command.js").then((m) => m.runHooks), {
-        needs: "none",
+    declareCommand(commitSpec, { load: loadCommitSpec }),
+    declareCommand(startSpec, { load: loadStartSpec }),
+    declareCommand(blockSpec, { load: loadBlockSpec }),
+    declareCommand(verifySpec, {
+        load: loadVerifySpec,
+        invocation: requireCanonicalCommandInvocation(["verify"]),
     }),
-    entry(hooksInstallSpec, () => import("../../../commands/hooks/install.command.js").then((m) => m.runHooksInstall)),
-    entry(hooksUninstallSpec, () => import("../../../commands/hooks/uninstall.command.js").then((m) => m.runHooksUninstall)),
-    entry(hooksRunSpec, () => import("../../../commands/hooks/run.command.js").then((m) => m.runHooksRun)),
-    entry(cleanupSpec, () => import("../../../commands/cleanup/merged.command.js").then((m) => m.runCleanup), {
-        needs: "none",
-    }),
-    entry(cleanupMergedSpec, (deps) => import("../../../commands/cleanup/merged.command.js").then((m) => m.makeRunCleanupMergedHandler(deps.getCtx))),
-    entry(guardSpec, () => import("../../../commands/guard/guard.command.js").then((m) => m.runGuard), {
-        needs: "none",
+    declareCommand(finishSpec, {
+        load: loadFinishSpec,
+        invocation: requireCanonicalCommandInvocation(["finish"]),
     }),
-    entry(guardCleanSpec, () => import("../../../commands/guard/clean.command.js").then((m) => m.runGuardClean)),
-    entry(guardSuggestAllowSpec, () => import("../../../commands/guard/suggest-allow.command.js").then((m) => m.runGuardSuggestAllow)),
-    entry(guardCommitSpec, (deps) => import("../../../commands/guard/commit.command.js").then((m) => m.makeRunGuardCommitHandler(deps.getCtx))),
+    declareCommand(readySpec, { load: loadReadySpec }),
+    declareCommand(docsCliSpec, { load: loadDocsCliSpec, needs: "none" }),
+    fromCommandsHooksHooksCommand(hooksSpec, "runHooks", { needs: "none" }),
+    fromCommandsHooksInstallCommand(hooksInstallSpec, "runHooksInstall", {}),
+    fromHooksUninstallSpec(hooksUninstallSpec, "runHooksUninstall"),
+    fromCommandsHooksRunCommand(hooksRunSpec, "runHooksRun", {}),
+    fromCleanupSpec(cleanupSpec, "runCleanup", { needs: "none" }),
+    declareCommand(cleanupMergedSpec, { load: loadCleanupMergedSpec }),
+    fromCommandsGuardGuardCommand(guardSpec, "runGuard", { needs: "none" }),
+    fromCommandsGuardCleanCommand(guardCleanSpec, "runGuardClean", {}),
+    fromGuardSuggestAllowSpec(guardSuggestAllowSpec, "runGuardSuggestAllow"),
+    declareCommand(guardCommitSpec, { load: loadGuardCommitSpec }),
 ];

package/dist/cli/run-cli/command-catalog/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/project.ts"],"names":[],"mappings":"AA4CA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,gBAAgB,ihBAkKe,CAAC"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/project.ts"],"names":[],"mappings":"AA4CA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAuChE,eAAO,MAAM,gBAAgB,ihBAsCe,CAAC"}

package/dist/cli/run-cli/command-catalog/project.js

@@ -22,59 +22,44 @@ import { recipesListSpec } from "../../../commands/recipes/list.command.js";
 import { recipesRemoveSpec } from "../../../commands/recipes/remove.command.js";
 import { recipesSpec } from "../../../commands/recipes/recipes.command.js";
 import { recipesUpdateSpec } from "../../../commands/recipes/update.command.js";
-import { entry } from "./shared.js";
+import { declareCommand } from "./shared.js";
+import { fromCommandsRecipesRecipesCommand, fromCommandsRecipesCacheCommand, fromCommandsRecipesAddCommand, fromCommandsRecipesListCommand, fromCommandsRecipesListRemoteCommand, fromCommandsRecipesExplainCommand, fromCommandsRecipesEnableCommand, fromCommandsRecipesRemoveCommand, fromCommandsRecipesDetachCommand, fromCommandsRecipesInstallRun, fromCommandsBranchBaseCommand, fromCommandsBranchStatusCommand, loadWorkStartSpec, fromRecipesActiveSpec, fromRecipesInfoSpec, loadRecipesExplainActiveSpec, fromRecipesDisableSpec, fromRecipesUpdateSpec, fromRecipesCachePruneSpec, fromBranchBaseSetSpec, fromBranchBaseExplainSpec, fromBranchRemoveSpec, loadBackendSpec, loadBackendSyncSpec, loadBackendInspectSpec, loadBackendMigrateCanonicalStateSpec, loadSyncSpec, loadPrSpec, loadPrOpenSpec, loadPrUpdateSpec, loadPrCheckSpec, loadPrCloseSpec, loadPrCloseSupersededSpec, loadPrNoteSpec, loadIntegrateSpec, } from "../command-loaders.js";
 export const PROJECT_COMMANDS = [
-    entry(workStartSpec, (deps) => import("../../../commands/branch/work-start.command.js").then((m) => m.makeRunWorkStartHandler(deps.getCtx))),
-    entry(recipesSpec, () => import("../../../commands/recipes/recipes.command.js").then((m) => m.runRecipes), {
-        needs: "none",
-    }),
-    entry(recipesCacheSpec, () => import("../../../commands/recipes/cache.command.js").then((m) => m.runRecipesCache), {
-        needs: "none",
-    }),
-    entry(recipesAddSpec, () => import("../../../commands/recipes/add.command.js").then((m) => m.runRecipesAdd)),
-    entry(recipesActiveSpec, () => import("../../../commands/recipes/active.command.js").then((m) => m.runRecipesActive)),
-    entry(recipesListSpec, () => import("../../../commands/recipes/list.command.js").then((m) => m.runRecipesList), {
-        needs: "none",
-    }),
-    entry(recipesListRemoteSpec, () => import("../../../commands/recipes/list-remote.command.js").then((m) => m.runRecipesListRemote)),
-    entry(recipesInfoSpec, () => import("../../../commands/recipes/info.command.js").then((m) => m.runRecipesInfo), {
-        needs: "none",
-    }),
-    entry(recipesExplainSpec, () => import("../../../commands/recipes/explain.command.js").then((m) => m.runRecipesExplain)),
-    entry(recipesExplainActiveSpec, () => import("../../../commands/recipes/explain-active.command.js").then((m) => m.runRecipesExplainActive)),
-    entry(recipesEnableSpec, () => import("../../../commands/recipes/enable.command.js").then((m) => m.runRecipesEnable)),
-    entry(recipesDisableSpec, () => import("../../../commands/recipes/disable.command.js").then((m) => m.runRecipesDisable)),
-    entry(recipesRemoveSpec, () => import("../../../commands/recipes/remove.command.js").then((m) => m.runRecipesRemove)),
-    entry(recipesUpdateSpec, () => import("../../../commands/recipes/update.command.js").then((m) => m.runRecipesUpdate)),
-    entry(recipesDetachSpec, () => import("../../../commands/recipes/detach.command.js").then((m) => m.runRecipesDetach)),
-    entry(recipesCachePruneSpec, () => import("../../../commands/recipes/cache-prune.command.js").then((m) => m.runRecipesCachePrune)),
-    entry(recipesInstallSpec, () => import("../../../commands/recipes/install.run.js").then((m) => m.runRecipesInstall), {
-        needs: "none",
-    }),
-    entry(branchBaseSpec, () => import("../../../commands/branch/base.command.js").then((m) => m.runBranchBase), {
-        needs: "none",
-    }),
-    entry(branchBaseGetSpec, () => import("../../../commands/branch/base.command.js").then((m) => m.runBranchBaseGet)),
-    entry(branchBaseSetSpec, () => import("../../../commands/branch/base.command.js").then((m) => m.runBranchBaseSet)),
-    entry(branchBaseClearSpec, () => import("../../../commands/branch/base.command.js").then((m) => m.runBranchBaseClear)),
-    entry(branchBaseExplainSpec, () => import("../../../commands/branch/base.command.js").then((m) => m.runBranchBaseExplain)),
-    entry(branchStatusSpec, () => import("../../../commands/branch/status.command.js").then((m) => m.runBranchStatus)),
-    entry(branchRemoveSpec, () => import("../../../commands/branch/remove.command.js").then((m) => m.runBranchRemove)),
-    entry(backendSpec, (deps) => import("../../../commands/backend/sync.command.js").then((m) => m.makeRunBackendHandler(deps.getCtx)), {
-        needs: "none",
-    }),
-    entry(backendSyncSpec, (deps) => import("../../../commands/backend/sync.command.js").then((m) => m.makeRunBackendSyncHandler(deps.getCtx))),
-    entry(backendInspectSpec, (deps) => import("../../../commands/backend/sync.command.js").then((m) => m.makeRunBackendInspectHandler(deps.getCtx))),
-    entry(backendMigrateCanonicalStateSpec, (deps) => import("../../../commands/backend/sync.command.js").then((m) => m.makeRunBackendMigrateCanonicalStateHandler(deps.getCtx))),
-    entry(syncSpec, (deps) => import("../../../commands/sync.command.js").then((m) => m.makeRunSyncHandler(deps.getCtx))),
-    entry(prSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrHandler(deps.getCtx)), {
-        needs: "none",
-    }),
-    entry(prOpenSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrOpenHandler(deps.getCtx))),
-    entry(prUpdateSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrUpdateHandler(deps.getCtx))),
-    entry(prCheckSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrCheckHandler(deps.getCtx))),
-    entry(prCloseSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrCloseHandler(deps.getCtx))),
-    entry(prCloseSupersededSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrCloseSupersededHandler(deps.getCtx))),
-    entry(prNoteSpec, (deps) => import("../../../commands/pr/pr.command.js").then((m) => m.makeRunPrNoteHandler(deps.getCtx))),
-    entry(integrateSpec, (deps) => import("../../../commands/integrate.command.js").then((m) => m.makeRunIntegrateHandler(deps.getCtx))),
+    declareCommand(workStartSpec, { load: loadWorkStartSpec }),
+    fromCommandsRecipesRecipesCommand(recipesSpec, "runRecipes", { needs: "none" }),
+    fromCommandsRecipesCacheCommand(recipesCacheSpec, "runRecipesCache", { needs: "none" }),
+    fromCommandsRecipesAddCommand(recipesAddSpec, "runRecipesAdd", {}),
+    fromRecipesActiveSpec(recipesActiveSpec, "runRecipesActive"),
+    fromCommandsRecipesListCommand(recipesListSpec, "runRecipesList", { needs: "none" }),
+    fromCommandsRecipesListRemoteCommand(recipesListRemoteSpec, "runRecipesListRemote", {}),
+    fromRecipesInfoSpec(recipesInfoSpec, "runRecipesInfo", { needs: "none" }),
+    fromCommandsRecipesExplainCommand(recipesExplainSpec, "runRecipesExplain", {}),
+    declareCommand(recipesExplainActiveSpec, { load: loadRecipesExplainActiveSpec }),
+    fromCommandsRecipesEnableCommand(recipesEnableSpec, "runRecipesEnable", {}),
+    fromRecipesDisableSpec(recipesDisableSpec, "runRecipesDisable"),
+    fromCommandsRecipesRemoveCommand(recipesRemoveSpec, "runRecipesRemove", {}),
+    fromRecipesUpdateSpec(recipesUpdateSpec, "runRecipesUpdate"),
+    fromCommandsRecipesDetachCommand(recipesDetachSpec, "runRecipesDetach", {}),
+    fromRecipesCachePruneSpec(recipesCachePruneSpec, "runRecipesCachePrune"),
+    fromCommandsRecipesInstallRun(recipesInstallSpec, "runRecipesInstall", { needs: "none" }),
+    fromCommandsBranchBaseCommand(branchBaseSpec, "runBranchBase", { needs: "none" }),
+    fromCommandsBranchBaseCommand(branchBaseGetSpec, "runBranchBaseGet", {}),
+    fromBranchBaseSetSpec(branchBaseSetSpec, "runBranchBaseSet"),
+    fromCommandsBranchBaseCommand(branchBaseClearSpec, "runBranchBaseClear", {}),
+    fromBranchBaseExplainSpec(branchBaseExplainSpec, "runBranchBaseExplain"),
+    fromCommandsBranchStatusCommand(branchStatusSpec, "runBranchStatus", {}),
+    fromBranchRemoveSpec(branchRemoveSpec, "runBranchRemove"),
+    declareCommand(backendSpec, { load: loadBackendSpec, needs: "none" }),
+    declareCommand(backendSyncSpec, { load: loadBackendSyncSpec }),
+    declareCommand(backendInspectSpec, { load: loadBackendInspectSpec }),
+    declareCommand(backendMigrateCanonicalStateSpec, { load: loadBackendMigrateCanonicalStateSpec }),
+    declareCommand(syncSpec, { load: loadSyncSpec }),
+    declareCommand(prSpec, { load: loadPrSpec, needs: "none" }),
+    declareCommand(prOpenSpec, { load: loadPrOpenSpec }),
+    declareCommand(prUpdateSpec, { load: loadPrUpdateSpec }),
+    declareCommand(prCheckSpec, { load: loadPrCheckSpec }),
+    declareCommand(prCloseSpec, { load: loadPrCloseSpec }),
+    declareCommand(prCloseSupersededSpec, { load: loadPrCloseSupersededSpec }),
+    declareCommand(prNoteSpec, { load: loadPrNoteSpec }),
+    declareCommand(integrateSpec, { load: loadIntegrateSpec }),
 ];

package/dist/cli/run-cli/command-catalog/shared.d.ts

@@ -21,11 +21,23 @@ export type CommandEntry = {
     dispatch: DispatchNeeds;
     invocation?: string;
 };
-type CommandMeta = {
+export type CommandMeta = {
     needs?: CommandNeeds;
     invocation?: string;
 };
-export declare function declareCommand<TParsed>(spec: CommandSpec<TParsed>, load: (deps: RunDeps) => Promise<CommandHandler<TParsed>>, meta?: CommandMeta): CommandEntry;
-export declare function entry<TParsed>(spec: CommandSpec<TParsed>, load: (deps: RunDeps) => Promise<CommandHandler<TParsed>>, meta?: CommandMeta): CommandEntry;
+export type CommandModule = object;
+type LoadedCommandDeclaration<TParsed> = CommandMeta & {
+    load: (deps: RunDeps) => Promise<CommandHandler<TParsed>>;
+    module?: never;
+    runExport?: never;
+};
+type ExportedCommandDeclaration = CommandMeta & {
+    module: () => Promise<CommandModule>;
+    runExport: string;
+    load?: never;
+};
+type CommandDeclaration<TParsed> = LoadedCommandDeclaration<TParsed> | ExportedCommandDeclaration;
+export declare function declareCommand<TParsed>(spec: CommandSpec<TParsed>, declaration: CommandDeclaration<TParsed>): CommandEntry;
+export declare function commandModule<TModule extends CommandModule>(module: () => Promise<TModule>): <TParsed>(spec: CommandSpec<TParsed>, runExport: Extract<keyof TModule, string>, meta?: CommandMeta) => CommandEntry;
 export {};
 //# sourceMappingURL=shared.d.ts.map

package/dist/cli/run-cli/command-catalog/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtE,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,CAAC,sBAAsB,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IACpE,kBAAkB,EAAE,CAAC,sBAAsB,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACjF,eAAe,EAAE,CAAC,sBAAsB,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3E,kBAAkB,EAAE,MAAM,SAAS,QAAQ,EAAE,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,qBAAqB,CAAC;AAEzF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAmBF,wBAAgB,cAAc,CAAC,OAAO,EACpC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,EAC1B,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,EACzD,IAAI,CAAC,EAAE,WAAW,GACjB,YAAY,CASd;AAED,wBAAgB,KAAK,CAAC,OAAO,EAC3B,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,EAC1B,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,EACzD,IAAI,CAAC,EAAE,WAAW,GACjB,YAAY,CAEd"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtE,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,CAAC,sBAAsB,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IACpE,kBAAkB,EAAE,CAAC,sBAAsB,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACjF,eAAe,EAAE,CAAC,sBAAsB,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3E,kBAAkB,EAAE,MAAM,SAAS,QAAQ,EAAE,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,qBAAqB,CAAC;AAEzF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,aAAa,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC,KAAK,wBAAwB,CAAC,OAAO,IAAI,WAAW,GAAG;IACrD,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,CAAC;AAEF,KAAK,0BAA0B,GAAG,WAAW,GAAG;IAC9C,MAAM,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,KAAK,CAAC;CACd,CAAC;AAEF,KAAK,kBAAkB,CAAC,OAAO,IAAI,wBAAwB,CAAC,OAAO,CAAC,GAAG,0BAA0B,CAAC;AAmBlG,wBAAgB,cAAc,CAAC,OAAO,EACpC,IAAI,EAAE,WAAW,CAAC,OAAO,CAAC,EAC1B,WAAW,EAAE,kBAAkB,CAAC,OAAO,CAAC,GACvC,YAAY,CASd;AAED,wBAAgB,aAAa,CAAC,OAAO,SAAS,aAAa,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,IACpD,OAAO,EAC1C,MAAM,WAAW,CAAC,OAAO,CAAC,EAC1B,WAAW,OAAO,CAAC,MAAM,OAAO,EAAE,MAAM,CAAC,EACzC,OAAO,WAAW,KACjB,YAAY,CAGhB"}

package/dist/cli/run-cli/command-catalog/shared.js

@@ -14,16 +14,29 @@ function normalizeDispatchNeeds(needs) {
         }
     }
 }
-export function declareCommand(spec, load, meta) {
-    const needs = meta?.needs ?? "project+config+task";
+export function declareCommand(spec, declaration) {
+    const needs = declaration.needs ?? "project+config+task";
     return {
         spec: spec,
-        load: (deps) => load(deps),
+        load: (deps) => loadDeclaredCommand(declaration, deps),
         needs,
         dispatch: normalizeDispatchNeeds(needs),
-        invocation: meta?.invocation,
+        invocation: declaration.invocation,
     };
 }
-export function entry(spec, load, meta) {
-    return declareCommand(spec, load, meta);
+export function commandModule(module) {
+    return function declareModuleCommand(spec, runExport, meta) {
+        return declareCommand(spec, { module, runExport, ...meta });
+    };
+}
+async function loadDeclaredCommand(declaration, deps) {
+    if (typeof declaration.load === "function") {
+        return declaration.load(deps);
+    }
+    const module = await declaration.module();
+    const handler = module[declaration.runExport];
+    if (typeof handler !== "function") {
+        throw new Error(`Command module does not export handler "${declaration.runExport}"`);
+    }
+    return handler;
 }

package/dist/cli/run-cli/command-catalog/task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/task.ts"],"names":[],"mappings":"AAmDA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,aAAa,yrBA2PkB,CAAC"}
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../../src/cli/run-cli/command-catalog/task.ts"],"names":[],"mappings":"AAmDA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAqDhE,eAAO,MAAM,aAAa,yrBAuEkB,CAAC"}

package/dist/cli/run-cli/command-catalog/task.js

@@ -48,71 +48,77 @@ import { taskVerifyReworkSpec } from "../../../commands/task/verify-rework.comma
 import { taskVerifyShowSpec } from "../../../commands/task/verify-show.command.js";
 import { taskVerifySpec } from "../../../commands/task/verify.command.js";
 import { requireCanonicalCommandInvocation } from "../../command-invocations.js";
-import { entry } from "./shared.js";
+import { declareCommand } from "./shared.js";
+import { fromCommandsTaskTaskCommand, fromCommandsTaskHandoffCommand, fromCommandsTaskHandoffRecordCommand, fromCommandsTaskRunShowCommand, fromCommandsTaskRunTailCommand, fromCommandsTaskRunCancelCommand, fromCommandsTaskRunRetryCommand, fromCommandsTaskFindingsCommand, fromCommandsTaskDocCommand, fromCommandsTaskLintCommand, fromCommandsTaskMigrateDocCommand, fromCommandsTaskVerifyCommand, fromCommandsTaskResumeContextCommand, fromTaskHandoffShowSpec, loadTaskHostedCloseSpec, loadTaskHostedClosePrSpec, loadTaskListSpec, loadTaskNextSpec, loadTaskSearchSpec, loadTaskShowSpec, fromTaskRunTraceSpec, fromTaskRunSpec, fromTaskRunResumeSpec, loadTaskNewSpec, loadTaskDeriveSpec, loadTaskCloseDuplicateSpec, loadTaskStartReadySpec, loadTaskCloseNoopSpec, loadTaskAddSpec, loadTaskUpdateSpec, loadTaskCommentSpec, loadTaskSetStatusSpec, loadTaskFindingsAddSpec, loadTaskDocShowSpec, loadTaskDocSetSpec, loadTaskScrubSpec, loadTaskScaffoldSpec, loadTaskNormalizeSpec, loadTaskExportSpec, loadTaskMigrateSpec, fromTaskPlanSpec, loadTaskPlanSetSpec, loadTaskPlanApproveSpec, loadTaskPlanRejectSpec, loadTaskVerifyOkSpec, loadTaskVerifyReworkSpec, loadTaskVerifyShowSpec, loadTaskRebuildIndexSpec, fromTaskReclaimSpec, } from "../command-loaders.js";
 export const TASK_COMMANDS = [
-    entry(taskSpec, () => import("../../../commands/task/task.command.js").then((m) => m.runTask), {
-        needs: "none",
+    fromCommandsTaskTaskCommand(taskSpec, "runTask", { needs: "none" }),
+    fromCommandsTaskHandoffCommand(taskHandoffSpec, "runTaskHandoff", { needs: "none" }),
+    fromCommandsTaskHandoffRecordCommand(taskHandoffRecordSpec, "runTaskHandoffRecord", {}),
+    fromTaskHandoffShowSpec(taskHandoffShowSpec, "runTaskHandoffShow"),
+    declareCommand(taskHostedCloseSpec, { load: loadTaskHostedCloseSpec }),
+    declareCommand(taskHostedClosePrSpec, { load: loadTaskHostedClosePrSpec }),
+    declareCommand(taskListSpec, {
+        load: loadTaskListSpec,
+        invocation: requireCanonicalCommandInvocation(["task", "list"]),
     }),
-    entry(taskHandoffSpec, () => import("../../../commands/task/handoff.command.js").then((m) => m.runTaskHandoff), {
-        needs: "none",
+    declareCommand(taskNextSpec, { load: loadTaskNextSpec }),
+    declareCommand(taskSearchSpec, { load: loadTaskSearchSpec }),
+    declareCommand(taskShowSpec, {
+        load: loadTaskShowSpec,
+        invocation: requireCanonicalCommandInvocation(["task", "show"]),
     }),
-    entry(taskHandoffRecordSpec, () => import("../../../commands/task/handoff-record.command.js").then((m) => m.runTaskHandoffRecord)),
-    entry(taskHandoffShowSpec, () => import("../../../commands/task/handoff-show.command.js").then((m) => m.runTaskHandoffShow)),
-    entry(taskHostedCloseSpec, (deps) => import("../../../commands/task/hosted-close.command.js").then((m) => m.makeRunTaskHostedCloseHandler(deps.getCtx))),
-    entry(taskHostedClosePrSpec, (deps) => import("../../../commands/task/hosted-close-pr.command.js").then((m) => m.makeRunTaskHostedClosePrHandler(deps.getCtx))),
-    entry(taskListSpec, (deps) => import("../../../commands/task/list.run.js").then((m) => m.makeRunTaskListHandler(deps.getCtx)), { invocation: requireCanonicalCommandInvocation(["task", "list"]) }),
-    entry(taskNextSpec, (deps) => import("../../../commands/task/next.run.js").then((m) => m.makeRunTaskNextHandler(deps.getCtx))),
-    entry(taskSearchSpec, (deps) => import("../../../commands/task/search.run.js").then((m) => m.makeRunTaskSearchHandler(deps.getCtx))),
-    entry(taskShowSpec, (deps) => import("../../../commands/task/show.run.js").then((m) => m.makeRunTaskShowHandler(deps.getCtx)), { invocation: requireCanonicalCommandInvocation(["task", "show"]) }),
-    entry(taskRunShowSpec, () => import("../../../commands/task/run-show.command.js").then((m) => m.runTaskRunShow)),
-    entry(taskRunTraceSpec, () => import("../../../commands/task/run-trace.command.js").then((m) => m.runTaskRunTrace)),
-    entry(taskRunTailSpec, () => import("../../../commands/task/run-tail.command.js").then((m) => m.runTaskRunTail)),
-    entry(taskRunSpec, () => import("../../../commands/task/run.command.js").then((m) => m.runTaskRun)),
-    entry(taskRunCancelSpec, () => import("../../../commands/task/run-cancel.command.js").then((m) => m.runTaskRunCancel)),
-    entry(taskRunResumeSpec, () => import("../../../commands/task/run-resume.command.js").then((m) => m.runTaskRunResume)),
-    entry(taskRunRetrySpec, () => import("../../../commands/task/run-retry.command.js").then((m) => m.runTaskRunRetry)),
-    entry(taskNewSpec, (deps) => import("../../../commands/task/new.command.js").then((m) => m.makeRunTaskNewHandler(deps.getCtx)), {
+    fromCommandsTaskRunShowCommand(taskRunShowSpec, "runTaskRunShow", {}),
+    fromTaskRunTraceSpec(taskRunTraceSpec, "runTaskRunTrace"),
+    fromCommandsTaskRunTailCommand(taskRunTailSpec, "runTaskRunTail", {}),
+    fromTaskRunSpec(taskRunSpec, "runTaskRun"),
+    fromCommandsTaskRunCancelCommand(taskRunCancelSpec, "runTaskRunCancel", {}),
+    fromTaskRunResumeSpec(taskRunResumeSpec, "runTaskRunResume"),
+    fromCommandsTaskRunRetryCommand(taskRunRetrySpec, "runTaskRunRetry", {}),
+    declareCommand(taskNewSpec, {
+        load: loadTaskNewSpec,
         invocation: requireCanonicalCommandInvocation(["task", "new"]),
     }),
-    entry(taskDeriveSpec, (deps) => import("../../../commands/task/derive.command.js").then((m) => m.makeRunTaskDeriveHandler(deps.getCtx))),
-    entry(taskCloseDuplicateSpec, (deps) => import("../../../commands/task/close-duplicate.command.js").then((m) => m.makeRunTaskCloseDuplicateHandler(deps.getCtx))),
-    entry(taskStartReadySpec, (deps) => import("../../../commands/task/start-ready.command.js").then((m) => m.makeRunTaskStartReadyHandler(deps.getCtx)), {
+    declareCommand(taskDeriveSpec, { load: loadTaskDeriveSpec }),
+    declareCommand(taskCloseDuplicateSpec, { load: loadTaskCloseDuplicateSpec }),
+    declareCommand(taskStartReadySpec, {
+        load: loadTaskStartReadySpec,
         invocation: requireCanonicalCommandInvocation(["task", "start-ready"]),
     }),
-    entry(taskCloseNoopSpec, (deps) => import("../../../commands/task/close-noop.command.js").then((m) => m.makeRunTaskCloseNoopHandler(deps.getCtx))),
-    entry(taskAddSpec, (deps) => import("../../../commands/task/add.command.js").then((m) => m.makeRunTaskAddHandler(deps.getCtx))),
-    entry(taskUpdateSpec, (deps) => import("../../../commands/task/update.command.js").then((m) => m.makeRunTaskUpdateHandler(deps.getCtx))),
-    entry(taskCommentSpec, (deps) => import("../../../commands/task/comment.command.js").then((m) => m.makeRunTaskCommentHandler(deps.getCtx))),
-    entry(taskSetStatusSpec, (deps) => import("../../../commands/task/set-status.command.js").then((m) => m.makeRunTaskSetStatusHandler(deps.getCtx))),
-    entry(taskFindingsSpec, () => import("../../../commands/task/findings.command.js").then((m) => m.runTaskFindings), {
-        needs: "none",
+    declareCommand(taskCloseNoopSpec, { load: loadTaskCloseNoopSpec }),
+    declareCommand(taskAddSpec, { load: loadTaskAddSpec }),
+    declareCommand(taskUpdateSpec, { load: loadTaskUpdateSpec }),
+    declareCommand(taskCommentSpec, { load: loadTaskCommentSpec }),
+    declareCommand(taskSetStatusSpec, { load: loadTaskSetStatusSpec }),
+    fromCommandsTaskFindingsCommand(taskFindingsSpec, "runTaskFindings", { needs: "none" }),
+    declareCommand(taskFindingsAddSpec, { load: loadTaskFindingsAddSpec }),
+    fromCommandsTaskDocCommand(taskDocSpec, "runTaskDoc", { needs: "none" }),
+    declareCommand(taskDocShowSpec, { load: loadTaskDocShowSpec }),
+    declareCommand(taskDocSetSpec, { load: loadTaskDocSetSpec }),
+    declareCommand(taskScrubSpec, { load: loadTaskScrubSpec }),
+    declareCommand(taskScaffoldSpec, { load: loadTaskScaffoldSpec }),
+    declareCommand(taskNormalizeSpec, { load: loadTaskNormalizeSpec }),
+    declareCommand(taskExportSpec, { load: loadTaskExportSpec }),
+    fromCommandsTaskLintCommand(taskLintSpec, "runTaskLint", {}),
+    declareCommand(taskMigrateSpec, { load: loadTaskMigrateSpec }),
+    fromCommandsTaskMigrateDocCommand(taskMigrateDocSpec, "runTaskMigrateDoc", {}),
+    fromTaskPlanSpec(taskPlanSpec, "runTaskPlan", { needs: "none" }),
+    declareCommand(taskPlanSetSpec, {
+        load: loadTaskPlanSetSpec,
+        invocation: requireCanonicalCommandInvocation(["task", "plan", "set"]),
     }),
-    entry(taskFindingsAddSpec, (deps) => import("../../../commands/task/findings-add.command.js").then((m) => m.makeRunTaskFindingsAddHandler(deps.getCtx))),
-    entry(taskDocSpec, () => import("../../../commands/task/doc.command.js").then((m) => m.runTaskDoc), {
-        needs: "none",
+    declareCommand(taskPlanApproveSpec, {
+        load: loadTaskPlanApproveSpec,
+        invocation: requireCanonicalCommandInvocation(["task", "plan", "approve"]),
     }),
-    entry(taskDocShowSpec, (deps) => import("../../../commands/task/doc-show.command.js").then((m) => m.makeRunTaskDocShowHandler(deps.getCtx))),
-    entry(taskDocSetSpec, (deps) => import("../../../commands/task/doc-set.command.js").then((m) => m.makeRunTaskDocSetHandler(deps.getCtx))),
-    entry(taskScrubSpec, (deps) => import("../../../commands/task/scrub.command.js").then((m) => m.makeRunTaskScrubHandler(deps.getCtx))),
-    entry(taskScaffoldSpec, (deps) => import("../../../commands/task/scaffold.command.js").then((m) => m.makeRunTaskScaffoldHandler(deps.getCtx))),
-    entry(taskNormalizeSpec, (deps) => import("../../../commands/task/normalize.command.js").then((m) => m.makeRunTaskNormalizeHandler(deps.getCtx))),
-    entry(taskExportSpec, (deps) => import("../../../commands/task/export.command.js").then((m) => m.makeRunTaskExportHandler(deps.getCtx))),
-    entry(taskLintSpec, () => import("../../../commands/task/lint.command.js").then((m) => m.runTaskLint)),
-    entry(taskMigrateSpec, (deps) => import("../../../commands/task/migrate.command.js").then((m) => m.makeRunTaskMigrateHandler(deps.getCtx))),
-    entry(taskMigrateDocSpec, () => import("../../../commands/task/migrate-doc.command.js").then((m) => m.runTaskMigrateDoc)),
-    entry(taskPlanSpec, () => import("../../../commands/task/plan.command.js").then((m) => m.runTaskPlan), {
-        needs: "none",
+    declareCommand(taskPlanRejectSpec, { load: loadTaskPlanRejectSpec }),
+    fromCommandsTaskVerifyCommand(taskVerifySpec, "runTaskVerify", { needs: "none" }),
+    declareCommand(taskVerifyOkSpec, { load: loadTaskVerifyOkSpec }),
+    declareCommand(taskVerifyReworkSpec, { load: loadTaskVerifyReworkSpec }),
+    declareCommand(taskVerifyShowSpec, {
+        load: loadTaskVerifyShowSpec,
+        invocation: requireCanonicalCommandInvocation(["task", "verify-show"]),
     }),
-    entry(taskPlanSetSpec, (deps) => import("../../../commands/task/plan-set.command.js").then((m) => m.makeRunTaskPlanSetHandler(deps.getCtx)), { invocation: requireCanonicalCommandInvocation(["task", "plan", "set"]) }),
-    entry(taskPlanApproveSpec, (deps) => import("../../../commands/task/plan-approve.command.js").then((m) => m.makeRunTaskPlanApproveHandler(deps.getCtx)), { invocation: requireCanonicalCommandInvocation(["task", "plan", "approve"]) }),
-    entry(taskPlanRejectSpec, (deps) => import("../../../commands/task/plan-reject.command.js").then((m) => m.makeRunTaskPlanRejectHandler(deps.getCtx))),
-    entry(taskVerifySpec, () => import("../../../commands/task/verify.command.js").then((m) => m.runTaskVerify), {
-        needs: "none",
-    }),
-    entry(taskVerifyOkSpec, (deps) => import("../../../commands/task/verify-ok.command.js").then((m) => m.makeRunTaskVerifyOkHandler(deps.getCtx))),
-    entry(taskVerifyReworkSpec, (deps) => import("../../../commands/task/verify-rework.command.js").then((m) => m.makeRunTaskVerifyReworkHandler(deps.getCtx))),
-    entry(taskVerifyShowSpec, (deps) => import("../../../commands/task/verify-show.command.js").then((m) => m.makeRunTaskVerifyShowHandler(deps.getCtx)), { invocation: requireCanonicalCommandInvocation(["task", "verify-show"]) }),
-    entry(taskRebuildIndexSpec, (deps) => import("../../../commands/task/rebuild-index.command.js").then((m) => m.makeRunTaskRebuildIndexHandler(deps.getCtx))),
-    entry(taskResumeContextSpec, () => import("../../../commands/task/resume-context.command.js").then((m) => m.runTaskResumeContext)),
-    entry(taskReclaimSpec, () => import("../../../commands/task/reclaim.command.js").then((m) => m.runTaskReclaim)),
+    declareCommand(taskRebuildIndexSpec, { load: loadTaskRebuildIndexSpec }),
+    fromCommandsTaskResumeContextCommand(taskResumeContextSpec, "runTaskResumeContext", {}),
+    fromTaskReclaimSpec(taskReclaimSpec, "runTaskReclaim"),
 ];