@cassiomc1/forgeloop 1.12.0 → 1.14.0

package/src/core/cli-command-definitions.js

@@ -71,6 +71,188 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
     mayExecuteExternalProcess: false,
     description: "Reports versioning, lifecycle, command, guide, and public error compatibility metadata for external harnesses.",
   }),
+  "decision-status": Object.freeze({
+    name: "decision-status",
+    category: "diagnostics",
+    mutation: "READ_ONLY",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      "--health": Object.freeze({ targetKey: "health", parseType: "boolean", takesValue: false, description: "perform a bounded live Jev health check when credentials are configured" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit decision-plane status as JSON" }),
+    }),
+    writes: [], removes: [], mayExecuteExternalProcess: true,
+    description: "Reports the pinned semantic decision-plane configuration without exposing credentials.",
+  }),
+  "decision-show": Object.freeze({
+    name: "decision-show",
+    category: "diagnostics",
+    mutation: "READ_ONLY",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--decision": Object.freeze({ targetKey: "decisionId", parseType: "string", takesValue: true, valueName: "id", missingValueMessage: "--decision requires an ID", description: "decision artifact ID" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit the decision artifact as JSON" }),
+    }),
+    writes: [], removes: [], mayExecuteExternalProcess: false,
+    description: "Shows one persisted semantic decision artifact without performing a live request.",
+  }),
+  "context-plan": Object.freeze({
+    name: "context-plan",
+    category: "diagnostics",
+    mutation: "READ_ONLY",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--decision": Object.freeze({ targetKey: "decisionId", parseType: "string", takesValue: true, valueName: "id", missingValueMessage: "--decision requires an ID", description: "persisted Jev decision artifact ID" }),
+      "--profile": Object.freeze({ targetKey: "profile", parseType: "string", takesValue: true, valueName: "profile", missingValueMessage: "--profile requires light, balanced, or full", description: "bounded context budget profile" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit the bounded context plan as JSON" }),
+    }),
+    writes: [], removes: [], mayExecuteExternalProcess: false,
+    description: "Compiles a bounded non-authoritative context plan from deterministic candidates.",
+  }),
+  "model-route": Object.freeze({
+    name: "model-route",
+    category: "diagnostics",
+    mutation: "READ_ONLY",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--decision": Object.freeze({ targetKey: "decisionId", parseType: "string", takesValue: true, valueName: "id", missingValueMessage: "--decision requires an ID", description: "persisted Jev decision artifact ID" }),
+      "--work": Object.freeze({ targetKey: "workType", parseType: "string", takesValue: true, valueName: "type", missingValueMessage: "--work requires a type", description: "declared work type" }),
+      "--surface": Object.freeze({ targetKey: "surfaces", parseType: "string", takesValue: true, valueName: "value", repeatable: true, missingValueMessage: "--surface requires a value", description: "affected surface" }),
+      "--risk": Object.freeze({ targetKey: "risks", parseType: "string", takesValue: true, valueName: "value", repeatable: true, missingValueMessage: "--risk requires a value", description: "task risk" }),
+      "--platform": Object.freeze({ targetKey: "platforms", parseType: "string", takesValue: true, valueName: "value", repeatable: true, missingValueMessage: "--platform requires a value", description: "affected platform" }),
+      "--behavior-change": Object.freeze({ targetKey: "behaviorChange", parseType: "boolean", takesValue: false, description: "declare behavior change" }),
+      "--executable-change": Object.freeze({ targetKey: "executableChange", parseType: "boolean", takesValue: false, description: "declare executable/configuration change" }),
+      "--generation-required": Object.freeze({ targetKey: "generationRequired", parseType: "boolean", takesValue: false, description: "declare that generation is required" }),
+      "--architecture-change": Object.freeze({ targetKey: "architectureChange", parseType: "boolean", takesValue: false, description: "declare an architectural change" }),
+      "--ambiguous": Object.freeze({ targetKey: "ambiguity", parseType: "boolean", takesValue: false, description: "declare unresolved ambiguity" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit model-route projection as JSON" }),
+    }),
+    writes: [], removes: [], mayExecuteExternalProcess: false,
+    description: "Projects a deterministic model-routing floor with advisory Jev escalation only.",
+  }),
+  "semantic-plan": Object.freeze({
+    name: "semantic-plan",
+    category: "diagnostics",
+    mutation: "READ_ONLY",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--decision": Object.freeze({ targetKey: "decisionId", parseType: "string", takesValue: true, valueName: "id", missingValueMessage: "--decision requires an ID", description: "persisted Jev decision artifact ID" }),
+      "--kind": Object.freeze({ targetKey: "semanticPlanKind", parseType: "string", takesValue: true, valueName: "failure|diagnosis|review", missingValueMessage: "--kind requires failure, diagnosis, or review", description: "bounded semantic planning projection" }),
+      "--input": Object.freeze({ targetKey: "semanticPlanInput", parseType: "json-object", takesValue: true, valueName: "json", missingValueMessage: "--input requires a JSON object", description: "bounded failure, diagnosis, or review context" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit semantic plan projection as JSON" }),
+    }),
+    writes: [], removes: [], mayExecuteExternalProcess: false,
+    description: "Projects fail-closed failure triage, diagnosis priority, or review planning without authority.",
+  }),
+  "test-inventory": Object.freeze({
+    name: "test-inventory",
+    category: "diagnostics",
+    mutation: "READ_ONLY",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit deterministic test inventory as JSON" }),
+    }),
+    writes: [], removes: [], mayExecuteExternalProcess: false,
+    description: "Discovers tests deterministically and assigns stable semantic test IDs without pruning authority.",
+  }),
+  "test-utility": Object.freeze({
+    name: "test-utility",
+    category: "diagnostics",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit test utility analysis as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/test-utility.json"], removes: [], mayExecuteExternalProcess: false,
+    description: "Persists non-evidence test utility analysis; never deletes tests or authorizes pruning.",
+  }),
+  "test-prune-plan": Object.freeze({
+    name: "test-prune-plan", category: "diagnostics", mutation: "READ_ONLY",
+    options: Object.freeze({ ...CLI_COMMON_OPTIONS, ...CLI_TASK_OPTION, "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit test prune plan as JSON" }) }),
+    writes: [], removes: [], mayExecuteExternalProcess: false,
+    description: "Projects KEEP, PROBE_REMOVAL, or BLOCKED without deleting tests.",
+  }),
+  "test-prune-probe": Object.freeze({
+    name: "test-prune-probe", category: "verification", mutation: "EXTERNAL_EXECUTION",
+    options: Object.freeze({ ...CLI_COMMON_OPTIONS, ...CLI_TASK_OPTION, "--test": Object.freeze({ targetKey: "testId", parseType: "string", takesValue: true, valueName: "id", missingValueMessage: "--test requires a test ID", description: "stable test ID to probe in isolation" }), "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit test prune probe as JSON" }) }),
+    writes: [], removes: [], mayExecuteExternalProcess: true,
+    description: "Runs only an isolated, fail-closed removal probe; never modifies the live worktree.",
+  }),
+  discover: Object.freeze({
+    name: "discover",
+    category: "lifecycle",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured discovery output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Records the canonical initial discovery milestone for a newly created task.",
+  }),
+  "contract-create": Object.freeze({
+    name: "contract-create",
+    category: "lifecycle",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--contract-file": Object.freeze({ targetKey: "contractFile", parseType: "string", takesValue: true, valueName: "path", missingValueMessage: "--contract-file requires a path", description: "validated JSON contract relative to the target" }),
+      "--preset": Object.freeze({ targetKey: "preset", parseType: "string", takesValue: true, valueName: "name", missingValueMessage: "--preset requires a name", description: "bounded contract preset: documentation, bug, feature, or release" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured contract output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/contract.json", ".forgeloop/task-state/<taskKey>/work-state.json", ".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Persists a validated contract and materializes the first real lifecycle checkpoint.",
+  }),
+  "contract-revise": Object.freeze({
+    name: "contract-revise",
+    category: "project-maintenance",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--contract-file": Object.freeze({ targetKey: "contractFile", parseType: "string", takesValue: true, valueName: "path", missingValueMessage: "--contract-file requires a path", description: "validated replacement JSON contract relative to the target" }),
+      "--preset": Object.freeze({ targetKey: "preset", parseType: "string", takesValue: true, valueName: "name", missingValueMessage: "--preset requires a name", description: "bounded replacement contract preset: documentation, bug, feature, or release" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured contract revision output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/contract.json", ".forgeloop/task-state/<taskKey>/work-state.json", ".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Replaces an existing contract canonically before execution while preserving task identity and invalidating derived evidence.",
+  }),
+  "gate-record": Object.freeze({
+    name: "gate-record", category: "lifecycle", mutation: "MUTATING",
+    options: Object.freeze({ ...CLI_COMMON_OPTIONS, ...CLI_TASK_OPTION,
+      "--gate": Object.freeze({ targetKey: "gate", parseType: "string", takesValue: true, valueName: "name", missingValueMessage: "--gate requires a name", description: "required gate name" }),
+      "--status": Object.freeze({ targetKey: "gateStatus", parseType: "string", takesValue: true, valueName: "status", missingValueMessage: "--status requires a status", description: "satisfied, unverified, or blocked" }),
+      "--artifact": Object.freeze({ targetKey: "gateArtifacts", parseType: "string", takesValue: true, repeatable: true, valueName: "path", missingValueMessage: "--artifact requires a path", description: "project-relative evidence artifact" }),
+      "--decision": Object.freeze({ targetKey: "gateDecisions", parseType: "string", takesValue: true, repeatable: true, valueName: "text", missingValueMessage: "--decision requires text", description: "caller-recorded gate decision" }),
+      "--unknown": Object.freeze({ targetKey: "gateUnknowns", parseType: "string", takesValue: true, repeatable: true, valueName: "text", missingValueMessage: "--unknown requires text", description: "known unresolved item" }),
+       "--assumption": Object.freeze({ targetKey: "gateAssumptions", parseType: "string", takesValue: true, repeatable: true, valueName: "text", missingValueMessage: "--assumption requires text", description: "approved local assumption" }),
+       "--evidence-file": Object.freeze({ targetKey: "gateEvidenceFile", parseType: "string", takesValue: true, valueName: "path", missingValueMessage: "--evidence-file requires a path", description: "bounded local descriptive evidence JSON" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured gate output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/gates/<gate>.json"], removes: [], mayExecuteExternalProcess: false,
+    description: "Records a required pre-execution gate with ForgeLoop-owned artifact hashes.",
+  }),
+  "gate-revalidate": Object.freeze({
+    name: "gate-revalidate", category: "lifecycle", mutation: "MUTATING",
+    options: Object.freeze({ ...CLI_COMMON_OPTIONS, ...CLI_TASK_OPTION,
+      "--gate": Object.freeze({ targetKey: "gate", parseType: "string", takesValue: true, valueName: "name", missingValueMessage: "--gate requires a name", description: "satisfied gate to refresh after safe artifact drift" }),
+      "--acknowledge-stale": Object.freeze({ targetKey: "acknowledgeStale", parseType: "boolean", takesValue: false, description: "explicitly acknowledge refresh of stale gate artifacts inside active task claims" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured gate revalidation output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/gates/<gate>.json", ".forgeloop/task-state/<taskKey>/events.ndjson"], removes: [], mayExecuteExternalProcess: false,
+    description: "Refreshes a stale satisfied gate after execution only when current identity and active claims prove the change is safe.",
+  }),
   init: Object.freeze({
     name: "init",
     category: "project-maintenance",
@@ -324,6 +506,7 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
       ...CLI_COMMON_OPTIONS,
       ...CLI_TASK_OPTION,
       "--compact": Object.freeze({ targetKey: "compact", parseType: "boolean", takesValue: false, description: "emit a bounded next-action projection" }),
+      "--explain": Object.freeze({ targetKey: "explain", parseType: "boolean", takesValue: false, description: "include bounded read-only blocker and recovery explanation" }),
       "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured output as JSON" }),
     }),
     writes: [],
@@ -975,6 +1158,20 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
     mayExecuteExternalProcess: false,
     description: "Removes work-state.json for the active task only, preserving sibling contract, routing, and ledger files.",
   }),
+  "checkpoint-revalidate": Object.freeze({
+    name: "checkpoint-revalidate",
+    category: "project-maintenance",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured revalidation output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/work-state.json", ".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Revalidates a safe ROUTED checkpoint after repository-only drift without changing contract or route identity.",
+  }),
   "reconcile-closure": Object.freeze({
     name: "reconcile-closure",
     category: "lifecycle",
@@ -991,7 +1188,7 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
     writes: [".forgeloop/task-state/<taskKey>/executions/exec-<id>.json", ".forgeloop/task-state/<taskKey>/work-state.json", ".forgeloop/task-state/<taskKey>/events.ndjson"],
     removes: [],
     mayExecuteExternalProcess: true,
-    description: "Refreshes the work-state checkpoint of an EXECUTING task whose objective is already satisfied in the current repository, after contract-bound executed evidence, so canonical completion can proceed.",
+    description: "Refreshes the work-state checkpoint of an EXECUTING, VERIFYING, or REVIEWING task whose objective is already satisfied in the current repository, after contract-bound executed evidence, so canonical completion can proceed.",
   }),
   "validate-receipt": Object.freeze({
     name: "validate-receipt",
@@ -1038,6 +1235,8 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
       ...CLI_TASK_OPTION,
       "--claim": Object.freeze({ targetKey: "claims", parseType: "string", takesValue: true, repeatable: true, valueName: "path", missingValueMessage: "--claim requires a path", description: "scoped file path or directory prefix claimed for mutation" }),
       "--contract-file": Object.freeze({ targetKey: "contractFile", parseType: "string", takesValue: true, valueName: "path", missingValueMessage: "--contract-file requires a path", description: "path to initial contract file" }),
+      "--preset": Object.freeze({ targetKey: "preset", parseType: "string", takesValue: true, valueName: "name", missingValueMessage: "--preset requires a name", description: "bounded contract preset: documentation, bug, feature, or release" }),
+      "--preview": Object.freeze({ targetKey: "preview", parseType: "boolean", takesValue: false, description: "preview the contract without creating lifecycle state" }),
       "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured output as JSON" }),
     }),
     writes: [".forgeloop/task-state/<taskKey>/task.json", ".forgeloop/task-state/<taskKey>/contract.json"],
@@ -1051,6 +1250,10 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
     mutation: "READ_ONLY",
     options: Object.freeze({
       ...CLI_COMMON_OPTIONS,
+      "--phase": Object.freeze({ targetKey: "phase", parseType: "string", takesValue: true, valueName: "phase", missingValueMessage: "--phase requires a phase", description: "only return tasks in this lifecycle phase" }),
+      "--active": Object.freeze({ targetKey: "active", parseType: "boolean", takesValue: false, description: "only return healthy tasks with active ownership and a non-terminal phase" }),
+      "--limit": Object.freeze({ targetKey: "limit", parseType: "non-negative-integer", takesValue: true, valueName: "number", missingValueMessage: "--limit requires a non-negative integer", description: "maximum tasks to return" }),
+      "--offset": Object.freeze({ targetKey: "offset", parseType: "non-negative-integer", takesValue: true, valueName: "number", missingValueMessage: "--offset requires a non-negative integer", description: "number of sorted tasks to skip" }),
       "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured output as JSON" }),
     }),
     writes: [],
@@ -1163,6 +1366,51 @@ export const CLI_COMMAND_DEFINITIONS = Object.freeze({
     mayExecuteExternalProcess: false,
     description: "Caller-acknowledged recovery of a STALE or ABANDONED task; records durable state and releases effective write claims.",
   }),
+  "task-abandon": Object.freeze({
+    name: "task-abandon",
+    category: "project-maintenance",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--acknowledge-abandonment": Object.freeze({ targetKey: "acknowledgeAbandonment", parseType: "boolean", takesValue: false, description: "explicitly acknowledge abandonment of an active task (required; not completion authority)" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured abandonment output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/recovery.json", ".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Explicitly abandons an active non-terminal task; records append-only evidence and releases claims without completion authority.",
+  }),
+  "task-repair-contract-bootstrap": Object.freeze({
+    name: "task-repair-contract-bootstrap",
+    category: "project-maintenance",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--acknowledge-repair": Object.freeze({ targetKey: "acknowledgeRepair", parseType: "boolean", takesValue: false, description: "explicit caller acknowledgement of the exact append-only repair (required)" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured repair output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/work-state.json", ".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Repairs the exact duplicate contract bootstrap defect without rewriting history; idempotent and append-only.",
+  }),
+  "task-migrate-contract-bootstrap-repair": Object.freeze({
+    name: "task-migrate-contract-bootstrap-repair",
+    category: "project-maintenance",
+    mutation: "MUTATING",
+    options: Object.freeze({
+      ...CLI_COMMON_OPTIONS,
+      ...CLI_TASK_OPTION,
+      "--acknowledge-migration": Object.freeze({ targetKey: "acknowledgeMigration", parseType: "boolean", takesValue: false, description: "fresh explicit caller acknowledgement of the exact legacy marker migration (required)" }),
+      "--json": Object.freeze({ targetKey: "json", parseType: "boolean", takesValue: false, description: "emit structured migration output as JSON" }),
+    }),
+    writes: [".forgeloop/task-state/<taskKey>/events.ndjson"],
+    removes: [],
+    mayExecuteExternalProcess: false,
+    description: "Migrates the exact legacy contract bootstrap repair marker by appending a bound migration event; the original marker and artifacts remain unchanged.",
+  }),
   "task-repair-legacy-recovery": Object.freeze({
     name: "task-repair-legacy-recovery",
     category: "project-maintenance",

package/src/core/command-executors.js

@@ -2,6 +2,7 @@ import { runDoctor } from "../commands/doctor.js";
 import { runStatus } from "../commands/status.js";
 import { runValidateState } from "../commands/validate-state.js";
 import { runClearState } from "../commands/clear-state.js";
+import { runCheckpointRevalidate } from "../commands/checkpoint-revalidate.js";
 import { inspectTarget } from "../commands/inspect.js";
 import { runInit } from "../commands/init.js";
 import { runRoute } from "../commands/route.js";
@@ -57,6 +58,11 @@ import { runRecordContinuity } from "../commands/record-continuity.js";
 import { runReconcileContinuity } from "../commands/reconcile-continuity.js";
 import { runClearContinuity } from "../commands/clear-continuity.js";
 import { runTaskCreate } from "../commands/task-create.js";
+import { runDiscover } from "../commands/discover.js";
+import { runContractCreate } from "../commands/contract-create.js";
+import { runContractRevise } from "../commands/contract-revise.js";
+import { runGateRecord } from "../commands/gate-record.js";
+import { runGateRevalidate } from "../commands/gate-revalidate.js";
 import { runTaskList } from "../commands/task-list.js";
 import { runTaskShow } from "../commands/task-show.js";
 import { runTaskScope } from "../commands/task-scope.js";
@@ -64,10 +70,22 @@ import { runTaskMigrate } from "../commands/task-migrate.js";
 import { runMigrateProtocol } from "../commands/migrate-protocol.js";
 import { runTaskUnlock } from "../commands/task-unlock.js";
 import { runTaskRecover } from "../commands/task-recover.js";
+import { runTaskAbandon } from "../commands/task-abandon.js";
 import { runTaskResume } from "../commands/task-resume.js";
 import { runTaskRepairLegacyRecovery } from "../commands/task-repair-legacy-recovery.js";
+import { runTaskRepairContractBootstrap } from "../commands/task-repair-contract-bootstrap.js";
+import { runTaskMigrateContractBootstrapRepair } from "../commands/task-migrate-contract-bootstrap-repair.js";
 import { runTaskLockStatus } from "../commands/task-lock-status.js";
 import { runProtocolInfo } from "../commands/protocol-info.js";
+import { runDecisionStatus } from "../commands/decision-status.js";
+import { runDecisionShow } from "../commands/decision-show.js";
+import { runContextPlan } from "../commands/context-plan.js";
+import { runModelRoute } from "../commands/model-route.js";
+import { runSemanticPlan } from "../commands/semantic-plan.js";
+import { runTestInventory } from "../commands/test-inventory.js";
+import { runTestUtility } from "../commands/test-utility.js";
+import { runTestPrunePlan } from "../commands/test-prune-plan.js";
+import { runTestPruneProbe } from "../commands/test-prune-probe.js";
 import { runWorkspaceBind } from "../commands/workspace-bind.js";
 import { runWorkspaceStatus } from "../commands/workspace-status.js";
 import { runHandoffCreate } from "../commands/handoff-create.js";
@@ -103,10 +121,81 @@ import {
  * directly. No ownership, recovery, or lifecycle logic may live here.
  */
 export const COMMAND_EXECUTORS = {
+  discover: async ({ target, packageRoot, options }) => ({
+    result: await runDiscover({ target, packageRoot, taskId: options.taskId }),
+    exitCode: 0,
+  }),
+  "contract-create": async ({ target, packageRoot, options }) => ({
+    result: await runContractCreate({ target, packageRoot, taskId: options.taskId, preset: options.preset, contractFile: options.contractFile }),
+    exitCode: 0,
+  }),
+  "contract-revise": async ({ target, packageRoot, options }) => ({
+    result: await runContractRevise({ target, packageRoot, taskId: options.taskId, preset: options.preset, contractFile: options.contractFile }),
+    exitCode: 0,
+  }),
+  "gate-record": async ({ target, packageRoot, options }) => ({
+    result: await runGateRecord({ target, packageRoot, taskId: options.taskId, gate: options.gate, status: options.gateStatus, artifacts: options.gateArtifacts, decisions: options.gateDecisions, unknowns: options.gateUnknowns, assumptions: options.gateAssumptions, evidenceFile: options.gateEvidenceFile }),
+    exitCode: 0,
+  }),
+  "gate-revalidate": async ({ target, packageRoot, options }) => ({
+    result: await runGateRevalidate({ target, packageRoot, taskId: options.taskId, gate: options.gate, acknowledgeStale: options.acknowledgeStale }),
+    exitCode: 0,
+  }),
   "protocol-info": async ({ packageVersion }) => ({
     result: await runProtocolInfo({ packageVersion }),
     exitCode: 0,
   }),
+  "decision-status": async ({ target, packageRoot, options }) => ({
+    result: await runDecisionStatus({ target, packageRoot, health: options.health }),
+    exitCode: 0,
+  }),
+  "decision-show": async ({ target, packageRoot, options }) => ({
+    result: await runDecisionShow({ target, packageRoot, taskId: options.taskId, decisionId: options.decisionId }),
+    exitCode: 0,
+  }),
+  "context-plan": async ({ target, packageRoot, options }) => ({
+    result: await runContextPlan({ target, packageRoot, taskId: options.taskId, decisionId: options.decisionId, profile: options.profile ?? "balanced" }),
+    exitCode: 0,
+  }),
+  "model-route": async ({ target, packageRoot, options }) => ({
+    result: await runModelRoute({
+      target, packageRoot, taskId: options.taskId, decisionId: options.decisionId,
+      workType: options.workType,
+      surfaces: options.surfaces,
+      risks: options.risks,
+      platforms: options.platforms,
+      behaviorChange: options.behaviorChange,
+      executableChange: options.executableChange,
+      generationRequired: options.generationRequired,
+      architectureChange: options.architectureChange,
+      ambiguity: options.ambiguity,
+    }),
+    exitCode: 0,
+  }),
+  "semantic-plan": async ({ target, packageRoot, options }) => ({
+    result: await runSemanticPlan({
+      target, packageRoot, taskId: options.taskId, decisionId: options.decisionId,
+      kind: options.semanticPlanKind,
+      input: options.semanticPlanInput ?? {},
+    }),
+    exitCode: 0,
+  }),
+  "test-inventory": async ({ target }) => ({
+    result: await runTestInventory({ target }),
+    exitCode: 0,
+  }),
+  "test-utility": async ({ target, packageRoot, options }) => ({
+    result: await runTestUtility({ target, packageRoot, taskId: options.taskId }),
+    exitCode: 0,
+  }),
+  "test-prune-plan": async ({ target, packageRoot, options }) => ({
+    result: await runTestPrunePlan({ target, packageRoot, taskId: options.taskId }),
+    exitCode: 0,
+  }),
+  "test-prune-probe": async ({ target, packageRoot, options }) => ({
+    result: await runTestPruneProbe({ target, packageRoot, taskId: options.taskId, testId: options.testId }),
+    exitCode: 0,
+  }),
   init: async ({ target, packageRoot, packageVersion, options }) => ({
     result: await runInit({ target, dryRun: options.dryRun, packageRoot, packageVersion, repositoryIndex: true }),
     exitCode: 0,
@@ -170,7 +259,7 @@ export const COMMAND_EXECUTORS = {
     exitCode: 0,
   }),
   next: async ({ target, packageRoot, options, authorityContext, runtimeContext }) => ({
-    result: await runNext({ target, packageRoot, taskId: options.taskId, authorityContext, runtimeContext, compact: options.compact }),
+    result: await runNext({ target, packageRoot, taskId: options.taskId, authorityContext, runtimeContext, compact: options.compact, explain: options.explain }),
     exitCode: 0,
   }),
   continuity: async ({ target, packageRoot, options }) => ({
@@ -593,6 +682,10 @@ export const COMMAND_EXECUTORS = {
     result: await runClearState({ target, taskId: options.taskId }),
     exitCode: 0,
   }),
+  "checkpoint-revalidate": async ({ target, packageRoot, options }) => ({
+    result: await runCheckpointRevalidate({ target, packageRoot, taskId: options.taskId }),
+    exitCode: 0,
+  }),
   "task-create": async ({ target, packageRoot, options }) => ({
     result: await runTaskCreate({
       target,
@@ -600,11 +693,13 @@ export const COMMAND_EXECUTORS = {
       taskId: options.taskId,
       claims: options.claims,
       contractFile: options.contractFile,
+      preset: options.preset,
+      preview: options.preview,
     }),
     exitCode: 0,
   }),
-  "task-list": async ({ target, packageRoot }) => ({
-    result: await runTaskList({ target, packageRoot }),
+  "task-list": async ({ target, packageRoot, options }) => ({
+    result: await runTaskList({ target, packageRoot, phase: options.phase, active: options.active, limit: options.limit, offset: options.offset }),
     exitCode: 0,
   }),
   "task-show": async ({ target, packageRoot, options }) => ({
@@ -646,10 +741,27 @@ export const COMMAND_EXECUTORS = {
     }),
     exitCode: 0,
   }),
+  "task-abandon": async ({ target, packageRoot, options }) => ({
+    result: await runTaskAbandon({
+      target,
+      packageRoot,
+      taskId: options.taskId,
+      acknowledgeAbandonment: options.acknowledgeAbandonment,
+    }),
+    exitCode: 0,
+  }),
   "task-resume": async ({ target, packageRoot, options }) => ({
     result: await runTaskResume({ target, packageRoot, taskId: options.taskId, claims: options.claims }),
     exitCode: 0,
   }),
+  "task-repair-contract-bootstrap": async ({ target, packageRoot, options }) => ({
+    result: await runTaskRepairContractBootstrap({ target, packageRoot, taskId: options.taskId, acknowledgeRepair: options.acknowledgeRepair }),
+    exitCode: 0,
+  }),
+  "task-migrate-contract-bootstrap-repair": async ({ target, packageRoot, options }) => ({
+    result: await runTaskMigrateContractBootstrapRepair({ target, packageRoot, taskId: options.taskId, acknowledgeMigration: options.acknowledgeMigration }),
+    exitCode: 0,
+  }),
   "task-repair-legacy-recovery": async ({ target, packageRoot, options }) => ({
     result: await runTaskRepairLegacyRecovery({
       target,