@cassiomc1/forgeloop 1.13.0 → 1.14.0

package/src/core/integration-invocation-policy.js

@@ -24,7 +24,7 @@ export const INTEGRATION_RISK_CLASSES = Object.freeze({
 });
 
 const READ_ONLY_COMMANDS = Object.freeze(new Set([
-  "protocol-info", "status", "next", "continuity", "reconcile-continuity",
+  "protocol-info", "decision-status", "decision-show", "context-plan", "model-route", "semantic-plan", "test-inventory", "status", "next", "continuity", "reconcile-continuity",
   "task-list", "task-show", "task-lock-status", "progress", "audit", "report",
   "inspect", "validate-state", "validate-protocol", "validate-receipt",
   "policy-status", "policy-diff", "rule-verify", "policy",
@@ -37,7 +37,7 @@ const READ_ONLY_COMMANDS = Object.freeze(new Set([
 ]));
 
 const LOOP_MUTATION_COMMANDS = Object.freeze(new Set([
-  "route", "preflight", "advance", "task-create", "task-scope",
+  "discover", "contract-create", "route", "preflight", "advance", "task-create", "task-scope",
   "record-continuity", "clear-continuity", "prepare-completion",
   "record-check", "record-diagnosis", "record-decision-criterion",
   "record-terminal-result", "complete",
@@ -86,7 +86,17 @@ const STATIC_RISK_CLASSES = Object.freeze({
   bundle: INTEGRATION_RISK_CLASSES.MAINTENANCE,
   "profile-interview": INTEGRATION_RISK_CLASSES.MAINTENANCE,
   "task-recover": INTEGRATION_RISK_CLASSES.CLAIM_RELEASE_RECOVERY,
+  "task-abandon": INTEGRATION_RISK_CLASSES.CLAIM_RELEASE_RECOVERY,
   "task-repair-legacy-recovery": INTEGRATION_RISK_CLASSES.LEGACY_MIGRATION,
+  "gate-record": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "gate-revalidate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "test-utility": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "test-prune-plan": INTEGRATION_RISK_CLASSES.READ_ONLY,
+  "test-prune-probe": INTEGRATION_RISK_CLASSES.EXTERNAL_EXECUTION,
+  "task-repair-contract-bootstrap": INTEGRATION_RISK_CLASSES.LEGACY_MIGRATION,
+  "task-migrate-contract-bootstrap-repair": INTEGRATION_RISK_CLASSES.LEGACY_MIGRATION,
+  "checkpoint-revalidate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
+  "contract-revise": INTEGRATION_RISK_CLASSES.MAINTENANCE,
 });
 
 // Sparse input-dependent refinements over the static table.
@@ -169,6 +179,18 @@ export function getForgeLoopCapabilities({ packageVersion = null } = {}) {
         commands: ["next", "task-show"],
         preservesDefaultOutput: true,
       },
+      auditUx: {
+        version: 1,
+        supported: true,
+        readOnly: true,
+        resource: "task/audit-view",
+        timeline: true,
+        lifecycleAuthority: false,
+        evidenceAuthority: false,
+        completionAuthority: false,
+        mutationAuthority: false,
+        externalExecution: false,
+      },
       usageTelemetry: {
         version: 1,
         supported: true,
@@ -295,6 +317,7 @@ export function getForgeLoopCapabilities({ packageVersion = null } = {}) {
       { name: "task/approvals", scope: "TASK" },
       { name: "task/metrics", scope: "TASK" },
       { name: "task/context", scope: "TASK" },
+      { name: "task/audit-view", scope: "TASK" },
       { name: "task/evaluations", scope: "TASK" },
       { name: "project/capability-policy", scope: "PROJECT" },
       { name: "repository/index-status", scope: "PROJECT" },
@@ -352,8 +375,8 @@ export function classifyForgeLoopInvocation(command, input = {}) {
     removesArtifacts: definition.removes.length > 0,
     executesExternalProcess: definition.mayExecuteExternalProcess === true,
     affectsClaimAuthority: [
-      "task-resume", "task-recover", "task-repair-legacy-recovery",
-      "task-create", "task-scope", "complete",
+      "task-resume", "task-recover", "task-repair-legacy-recovery", "task-repair-contract-bootstrap",
+      "task-create", "task-scope", "complete", "task-migrate-contract-bootstrap-repair",
     ].includes(command),
     destructive: [
       INTEGRATION_RISK_CLASSES.AUTHORITY_MUTATION,

package/src/core/integration-resources.js

@@ -21,6 +21,12 @@ import { resolveAttestationStatus } from "./attestation.js";
 import { buildExecutionProfileContext } from "./execution-profile-context.js";
 import { projectStructuralQualityStatus } from "./structural-quality/service.js";
 import { getRepositoryIndexStatus } from "../repository-index/status.js";
+import { buildAuditUxView } from "./audit-ux.js";
+import { runContextPlan } from "../commands/context-plan.js";
+import { runModelRoute } from "../commands/model-route.js";
+import { readPersistedRoute } from "./route-artifact.js";
+import { readWorkState } from "./work-state.js";
+import { readTestUtility } from "./test-intelligence/service.js";
 
 /**
  * Canonical integration resource allowlist.
@@ -86,11 +92,18 @@ export const INTEGRATION_RESOURCE_DEFINITIONS = Object.freeze({
   "task/approvals": Object.freeze({ scope: "TASK", description: "Durable approval artifacts for one task." }),
   "task/metrics": Object.freeze({ scope: "TASK", description: "Read-only trajectory metrics for one task." }),
   "task/context": Object.freeze({ scope: "TASK", description: "Read-only profile-aware task context with bounded presentation policy." }),
+  "task/audit-view": Object.freeze({ scope: "TASK", description: "Bounded read-only Audit UX projection composed from canonical task resolvers." }),
   "task/evaluations": Object.freeze({ scope: "TASK", description: "Persisted trajectory evaluations for one task." }),
+  "task/decisions": Object.freeze({ scope: "TASK", description: "Persisted, fingerprint-bound semantic decisions without lifecycle or evidence authority." }),
+  "task/context-plan": Object.freeze({ scope: "TASK", description: "Bounded non-authoritative semantic context-plan projection." }),
+  "task/model-route": Object.freeze({ scope: "TASK", description: "Deterministic model-routing floor with advisory semantic escalation." }),
+  "task/test-utility": Object.freeze({ scope: "TASK", description: "Non-evidence test inventory and utility analysis; never deletion authority." }),
   "project/capability-policy": Object.freeze({ scope: "PROJECT", description: "Project capability policy, never host authority." }),
   "repository/index-status": Object.freeze({ scope: "PROJECT", description: "Provider-neutral repository-index health and owned-server status." }),
 });
 
+const TASK_RESOURCE_URIS = new Set(Object.keys(INTEGRATION_RESOURCE_DEFINITIONS).filter((uri) => uri.startsWith("task/")));
+
 function ownershipProjection(projection) {
   return {
     taskId: projection.taskId,
@@ -120,67 +133,20 @@ async function readForgeLoopIntegrationResourceCore(uri, {
     throw error;
   }
 
-  switch (uri) {
-    case "protocol/info": {
-      return { uri, data: await runProtocolInfo({ packageVersion }) };
-    }
-    case "project/tasks": {
-      const tasks = await discoverTasks(projectPath, packageRoot);
-      return {
-        uri,
-        data: {
-          count: tasks.length,
-          tasks: tasks.map((task) => ({
-            taskId: task.taskId,
-            healthy: task.healthy !== false,
-            phase: task.phase ?? null,
-            mutationAllowed: task.mutationAllowed !== false,
-          })),
-        },
-      };
-    }
-    case "task/status":
-    case "task/ownership":
-    case "task/contract":
-    case "task/continuity": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`);
-        error.code = "E_TASK_REQUIRED";
-        throw error;
-      }
-      break;
-    }
-    case "task/workspace-binding":
-    case "task/handoffs":
-    case "task/responsibility":
-    case "task/verification-scope":
-    case "task/attestation": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`);
-        error.code = "E_TASK_REQUIRED";
-        throw error;
-      }
-      break;
-    }
-    case "task/structural-quality": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`);
-        error.code = "E_TASK_REQUIRED";
-        throw error;
-      }
-      break;
-    }
-    case "task/actions":
-    case "task/action":
-    case "task/approvals":
-    case "task/metrics":
-    case "task/context":
-    case "task/evaluations": {
-      if (typeof taskId !== "string" || !taskId) {
-        const error = new Error(`Resource ${uri} requires a taskId`); error.code = "E_TASK_REQUIRED"; throw error;
-      }
-      break;
-    }
+  if (uri === "protocol/info") return { uri, data: await runProtocolInfo({ packageVersion }) };
+  if (uri === "project/tasks") {
+    const tasks = await discoverTasks(projectPath, packageRoot);
+    return { uri, data: { count: tasks.length, tasks: tasks.map((task) => ({
+      taskId: task.taskId,
+      healthy: task.healthy !== false,
+      phase: task.phase ?? null,
+      mutationAllowed: task.mutationAllowed !== false,
+    })) } };
+  }
+  if (TASK_RESOURCE_URIS.has(uri) && (typeof taskId !== "string" || !taskId)) {
+    const error = new Error(`Resource ${uri} requires a taskId`);
+    error.code = "E_TASK_REQUIRED";
+    throw error;
   }
 
   if (uri === "task/ownership") {
@@ -270,6 +236,45 @@ async function readForgeLoopIntegrationResourceCore(uri, {
     }
     return { uri, taskId, data: { evaluations } };
   }
+  if (uri === "task/decisions") {
+    const dir = path.join(projectPath, taskDirectory(taskId), "decisions");
+    let names = []; try { names = await readdir(dir); } catch { /* absent is an empty projection */ }
+    const decisions = [];
+    for (const name of names.filter((entry) => /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}\.json$/.test(entry)).sort()) {
+      decisions.push((await readJsonArtifact(projectPath, `${taskDirectory(taskId)}/decisions/${name}`, "semantic-decision", packageRoot)).value);
+    }
+    return { uri, taskId, data: { taskId, decisions } };
+  }
+  if (uri === "task/context-plan") {
+    return { uri, taskId, data: await runContextPlan({ target: projectPath, packageRoot, taskId, profile: runtimeContext?.contextProfile ?? "balanced", readOnly: true }) };
+  }
+  if (uri === "task/model-route") {
+    const state = await readWorkState(projectPath, { packageRoot, taskId });
+    const route = await readPersistedRoute(projectPath, packageRoot, { taskId });
+    return {
+      uri,
+      taskId,
+      data: await runModelRoute({
+        target: projectPath,
+        packageRoot,
+        taskId,
+        workType: route.value.input?.workType,
+        surfaces: route.value.input?.surfaces,
+        risks: route.value.input?.risks,
+        platforms: route.value.input?.platforms,
+        behaviorChange: route.value.input?.behaviorChange,
+        executableChange: route.value.input?.executableChange,
+        generationRequired: route.value.input?.generationRequired,
+        architectureChange: route.value.input?.architectureChange,
+        ambiguity: route.value.input?.ambiguity,
+        contract: { phase: state.phase },
+      }),
+    };
+  }
+  if (uri === "task/test-utility") {
+    const artifact = await readTestUtility({ target: projectPath, packageRoot, taskId });
+    return { uri, taskId, data: artifact.value };
+  }
   if (uri === "project/capability-policy") {
     return { uri, data: await loadCapabilityPolicy(projectPath, packageRoot) };
   }
@@ -292,6 +297,26 @@ async function readForgeLoopIntegrationResourceCore(uri, {
 }
 
 export async function readForgeLoopIntegrationResource(uri, options = {}) {
+  if (uri === "task/audit-view") {
+    if (typeof options.taskId !== "string" || !options.taskId) {
+      const error = new Error("Resource task/audit-view requires a taskId"); error.code = "E_TASK_REQUIRED"; throw error;
+    }
+    return {
+      uri,
+      taskId: options.taskId,
+      data: await buildAuditUxView({
+        target: options.projectPath ?? ".",
+        packageRoot: options.packageRoot,
+        taskId: options.taskId,
+        limit: options.limit,
+        beforeSequence: options.beforeSequence,
+        afterSequence: options.afterSequence,
+        categories: options.categories,
+        authorityContext: options.runtimeContext?.authorityContext,
+        runtimeContext: options.runtimeContext,
+      }),
+    };
+  }
   if (uri === "repository/index-status") {
     return {
       uri,

package/src/core/model-router/constants.js

@@ -0,0 +1,10 @@
+import { DECISION_AUTHORITY, DECISION_EVIDENCE_AUTHORITY, PINNED_JEV_MODEL } from "../decision/constants.js";
+
+export const MODEL_ROUTE_TIERS = Object.freeze(["NONE", "FAST", "STANDARD", "PRIMARY"]);
+export const MODEL_ROUTE_POLICY_VERSION = 1;
+export const MODEL_ROUTE_PROJECTION_AUTHORITY = DECISION_AUTHORITY;
+export const MODEL_ROUTE_PROJECTION_EVIDENCE_AUTHORITY = DECISION_EVIDENCE_AUTHORITY;
+export const MODEL_ROUTE_JEV_MODEL = PINNED_JEV_MODEL;
+
+export const MODEL_ROUTE_RANK = Object.freeze({ NONE: 0, FAST: 1, STANDARD: 2, PRIMARY: 3 });
+

package/src/core/model-router/policy.js

@@ -0,0 +1,103 @@
+import { MODEL_ROUTE_RANK, MODEL_ROUTE_TIERS } from "./constants.js";
+
+const GENERATION_WORK_TYPES = new Set([
+  "code", "bug", "refactor", "backend", "api", "infrastructure", "security-review", "release",
+]);
+const PRIMARY_WORK_TYPES = new Set(["infrastructure", "security-review", "release"]);
+const PRIMARY_RISKS = new Set(["secrets", "personal-data", "publication", "critical-path", "destructive", "irreversible", "migration", "credentials", "payment"]);
+const PRIMARY_SURFACES = new Set(["auth", "critical-path", "database"]);
+
+function text(value) {
+  return typeof value === "string" ? value.toLowerCase() : "";
+}
+
+function array(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+function contractText(contract) {
+  if (!contract || typeof contract !== "object" || Array.isArray(contract)) return "";
+  const values = [contract.objective, contract.summary, ...(contract.deliverables ?? []), ...(contract.successCriteria ?? []), ...(contract.risks ?? []), ...(contract.constraints ?? [])];
+  return values.map((value) => value && typeof value === "object" ? value.text : value).filter((value) => typeof value === "string").join(" ").toLowerCase();
+}
+
+function normalizedInput(input = {}) {
+  return {
+    workType: text(input.workType),
+    surfaces: array(input.surfaces).map(text),
+    risks: array(input.risks).map(text),
+    platforms: array(input.platforms).map(text),
+    behaviorChange: input.behaviorChange === true,
+    executableChange: input.executableChange === true,
+    generationRequired: input.generationRequired === true,
+    architectureChange: input.architectureChange === true,
+    ambiguity: input.ambiguity === true,
+    contract: input.contract,
+  };
+}
+
+function deterministicFloor(input) {
+  const normalized = normalizedInput(input);
+  const reasons = [];
+  const combined = `${contractText(normalized.contract)} ${normalized.workType} ${normalized.surfaces.join(" ")} ${normalized.risks.join(" ")}`;
+  const generationRequired = normalized.generationRequired
+    || normalized.behaviorChange
+    || normalized.executableChange
+    || GENERATION_WORK_TYPES.has(normalized.workType)
+    || /\b(implement|fix|refactor|change|build|generate|write|modify|code)\b/.test(combined);
+  const primary = normalized.architectureChange
+    || normalized.ambiguity
+    || PRIMARY_WORK_TYPES.has(normalized.workType)
+    || normalized.risks.some((risk) => PRIMARY_RISKS.has(risk))
+    || normalized.surfaces.some((surface) => PRIMARY_SURFACES.has(surface))
+    || /\b(architecture|architectural|security boundary|migration|ambiguous|unknown requirements)\b/.test(combined);
+
+  if (!generationRequired) {
+    reasons.push("NO_GENERATION_REQUIRED");
+    return { floor: "NONE", reasons };
+  }
+  reasons.push("GENERATION_REQUIRED");
+  if (primary) {
+    reasons.push("PRIMARY_COMPLEXITY_OR_RISK");
+    return { floor: "PRIMARY", reasons };
+  }
+  reasons.push("STANDARD_GENERATION_FLOOR");
+  return { floor: "STANDARD", reasons };
+}
+
+function normalizeRecommendation(recommendation) {
+  if (recommendation === null || recommendation === undefined) return null;
+  if (typeof recommendation === "string") {
+    return MODEL_ROUTE_TIERS.includes(recommendation) ? { tier: recommendation, confidence: null, requiresEscalation: false } : null;
+  }
+  if (!recommendation || typeof recommendation !== "object" || Array.isArray(recommendation)) return null;
+  const tier = typeof recommendation.tier === "string" && MODEL_ROUTE_TIERS.includes(recommendation.tier) ? recommendation.tier : null;
+  if (!tier) return null;
+  return {
+    tier,
+    confidence: typeof recommendation.confidence === "number" && Number.isFinite(recommendation.confidence) ? recommendation.confidence : null,
+    requiresEscalation: recommendation.requiresEscalation === true,
+  };
+}
+
+export function resolveModelRoute({ input = {}, semanticRecommendation = null } = {}) {
+  const deterministic = deterministicFloor(input);
+  const recommendation = normalizeRecommendation(semanticRecommendation);
+  let resolved = deterministic.floor;
+  const reasons = [...deterministic.reasons];
+  if (recommendation?.requiresEscalation) {
+    if (MODEL_ROUTE_RANK[resolved] < MODEL_ROUTE_RANK.PRIMARY) resolved = "PRIMARY";
+    reasons.push("JEV_LOW_CONFIDENCE_ESCALATION");
+  } else if (recommendation && MODEL_ROUTE_RANK[recommendation.tier] > MODEL_ROUTE_RANK[resolved]) {
+    resolved = recommendation.tier;
+    reasons.push("JEV_ESCALATION_ONLY");
+  }
+  return {
+    floor: deterministic.floor,
+    resolved,
+    reasons: [...new Set(reasons)],
+    semanticRecommendation: recommendation,
+    generationRequired: deterministic.floor !== "NONE",
+  };
+}
+

package/src/core/model-router/router.js

@@ -0,0 +1,37 @@
+import {
+  MODEL_ROUTE_JEV_MODEL,
+  MODEL_ROUTE_POLICY_VERSION,
+  MODEL_ROUTE_PROJECTION_AUTHORITY,
+  MODEL_ROUTE_PROJECTION_EVIDENCE_AUTHORITY,
+  MODEL_ROUTE_RANK,
+  MODEL_ROUTE_TIERS,
+} from "./constants.js";
+import { resolveModelRoute } from "./policy.js";
+
+export function projectModelRoute({ input = {}, semanticRecommendation = null } = {}) {
+  const route = resolveModelRoute({ input, semanticRecommendation });
+  if (!MODEL_ROUTE_TIERS.includes(route.floor) || !MODEL_ROUTE_TIERS.includes(route.resolved)
+    || MODEL_ROUTE_RANK[route.resolved] < MODEL_ROUTE_RANK[route.floor]) {
+    const error = new Error("Model route violates its deterministic safety floor.");
+    error.code = "E_MODEL_ROUTE_SAFETY_FLOOR_INVALID";
+    throw error;
+  }
+  return {
+    schemaVersion: 1,
+    policyVersion: MODEL_ROUTE_POLICY_VERSION,
+    engine: "typesafe-jev",
+    model: MODEL_ROUTE_JEV_MODEL,
+    floor: route.floor,
+    resolved: route.resolved,
+    reasons: route.reasons,
+    generationRequired: route.generationRequired,
+    semanticRecommendation: route.semanticRecommendation,
+    authority: MODEL_ROUTE_PROJECTION_AUTHORITY,
+    evidenceAuthority: MODEL_ROUTE_PROJECTION_EVIDENCE_AUTHORITY,
+    lifecycleAuthority: false,
+    completionAuthority: false,
+    ownershipAuthority: false,
+    installationAuthority: false,
+  };
+}
+

package/src/core/next-action-model.js

@@ -6,6 +6,7 @@ export const NEXT_ACTIONS = Object.freeze({
   CREATE_CONTRACT: "CREATE_CONTRACT",
   ROUTE: "ROUTE",
   SATISFY_GATES: "SATISFY_GATES",
+  REVALIDATE_GATES: "REVALIDATE_GATES",
   RUN_PREFLIGHT: "RUN_PREFLIGHT",
   PLAN: "PLAN",
   START_EXECUTION: "START_EXECUTION",
@@ -47,6 +48,9 @@ export const NEXT_ACTIONS = Object.freeze({
   RECOVER_TASK: "RECOVER_TASK",
   RESUME_RECOVERED_TASK: "RESUME_RECOVERED_TASK",
   RESOLVE_RECOVERY_INCONSISTENCY: "RESOLVE_RECOVERY_INCONSISTENCY",
+  REPAIR_CONTRACT_BOOTSTRAP: "REPAIR_CONTRACT_BOOTSTRAP",
+  MIGRATE_CONTRACT_BOOTSTRAP_REPAIR: "MIGRATE_CONTRACT_BOOTSTRAP_REPAIR",
+  REVALIDATE_CHECKPOINT: "REVALIDATE_CHECKPOINT",
   NONE: "NONE",
 });
 
@@ -60,6 +64,33 @@ export function directCommandSpec(commandId, taskId, requiredInputs = []) {
   };
 }
 
+export function routeCommandSpec(taskId) {
+  return {
+    commandId: "route",
+    executable: "forgeloop",
+    subcommand: "route",
+    argv: ["route", `--task=${taskId}`, "--json"],
+    requiredInputs: [
+      { name: "workType", option: "--work=<type>" },
+      { name: "surface", option: "--surface=<value>", repeatable: true, optional: true },
+      { name: "risk", option: "--risk=<value>", repeatable: true, optional: true },
+      { name: "platform", option: "--platform=<value>", repeatable: true, optional: true },
+    ],
+  };
+}
+
+export function gateRevalidationCommandSpec(taskId, gate) {
+  return {
+    commandId: "gate-revalidate",
+    executable: "forgeloop",
+    subcommand: "gate-revalidate",
+    argv: ["gate-revalidate", `--task=${taskId}`, `--gate=${gate}`, "--acknowledge-stale", "--json"],
+    requiredInputs: [
+      { name: "acknowledgeStale", option: "--acknowledge-stale" },
+    ],
+  };
+}
+
 export function recoveryGuidanceForClassification(classification, taskId) {
   if (classification === "RECOVERABLE") {
     return {
@@ -167,8 +198,35 @@ export function result({
   };
 }
 
+export function contractBootstrapRepairGuidance(taskId, reason = null) {
+  const command = `forgeloop task-repair-contract-bootstrap --task ${taskId} --acknowledge-repair --json`;
+  return {
+    nextAction: NEXT_ACTIONS.REPAIR_CONTRACT_BOOTSTRAP,
+    commands: [command],
+    commandSpecs: [directCommandSpec("task-repair-contract-bootstrap", taskId, [
+      { name: "acknowledgeRepair", option: "--acknowledge-repair", description: "Explicit caller acknowledgement of the exact repair signature." },
+    ])],
+    reason: reason ?? { code: "E_CONTRACT_BOOTSTRAP_REPAIR_AVAILABLE", message: "The exact duplicate contract bootstrap defect is repairable through the official append-only command." },
+  };
+}
+
+export function contractBootstrapRepairMigrationGuidance(taskId, reason = null) {
+  const command = `forgeloop task-migrate-contract-bootstrap-repair --task ${taskId} --acknowledge-migration --json`;
+  return {
+    nextAction: NEXT_ACTIONS.MIGRATE_CONTRACT_BOOTSTRAP_REPAIR,
+    commands: [command],
+    commandSpecs: [directCommandSpec("task-migrate-contract-bootstrap-repair", taskId, [
+      { name: "acknowledgeMigration", option: "--acknowledge-migration", description: "Fresh explicit caller acknowledgement of the exact legacy marker migration." },
+    ])],
+    reason: reason ?? { code: "E_CONTRACT_BOOTSTRAP_REPAIR_MIGRATION_AVAILABLE", message: "The exact legacy contract bootstrap repair marker can be migrated through the official append-only command." },
+  };
+}
+
 export function commandFor(action) {
   return {
+    [NEXT_ACTIONS.ROUTE]: "forgeloop route --task <id> --work <type> --json",
+    [NEXT_ACTIONS.RESOLVE_STALE_ROUTE]: "forgeloop route --task <id> --work <type> --json",
+    [NEXT_ACTIONS.REVALIDATE_GATES]: "forgeloop gate-revalidate --task <id> --gate <name> --acknowledge-stale --json",
     [NEXT_ACTIONS.PLAN]: "forgeloop advance --to PLANNED",
     [NEXT_ACTIONS.RUN_PREFLIGHT]: "forgeloop preflight --json",
     [NEXT_ACTIONS.START_EXECUTION]: "forgeloop advance --to EXECUTING",