agentera 3.0.0-dev.6 → 3.0.0-dev.69

package/dist/cli/commands/verify.js

@@ -1,9 +1,11 @@
 import { main as evalSkillsMain } from "../../eval/evalSkills.js";
 import { main as semanticEvalMain } from "../../eval/semanticEval.js";
+import { evaluateHybridRoute } from "../../eval/hybridRouteEvaluation.js";
+import { routeEvaluationExitCode } from "./route.js";
 export const VERIFY_FAMILIES = ["eval"];
 export const RETIRED_VERIFY_FAMILIES = ["smoke"];
 export const VERIFY_TARGETS = {
-    eval: ["skills", "semantic"],
+    eval: ["skills", "semantic", "routing"],
 };
 export const VERIFY_FORMATS = ["text", "json"];
 export const VERIFY_DIAGNOSTIC_LINE_LIMIT = 20;
@@ -43,14 +45,14 @@ export function validateVerifyRequest(args) {
     if (family === "eval" && target === "skills" && args.run && args.dryRun) {
         throw new Error("unsupported eval skills request combines --run and --dry-run; choose one mode. " +
             "Safe default: omit --run to list the bounded dry-run plan without invoking a runtime. " +
-            "Syntax: agentera verify eval skills [--run] [--skill NAME] [--timeout SECONDS] [--parallel N] [--runtime auto|claude|opencode] [--format text|json]. " +
+            "Syntax: agentera verify eval skills [--run] [--skill NAME] [--timeout SECONDS] [--parallel N] [--runtime auto|opencode|cursor] [--format text|json]. " +
             "Example: agentera verify eval skills --dry-run --format json");
     }
     if (family === "eval" && target === "skills") {
         const runtime = String(args.runtime ?? "auto");
-        if (!["auto", "claude", "opencode"].includes(runtime)) {
-            throw new Error(`unsupported eval skills runtime '${runtime}'; valid runtimes: auto, claude, opencode. ` +
-                "Syntax: agentera verify eval skills [--run] [--runtime auto|claude|opencode] [--format text|json]. " +
+        if (!["auto", "opencode", "cursor"].includes(runtime)) {
+            throw new Error(`unsupported eval skills runtime '${runtime}'; valid runtimes: auto, opencode, cursor. ` +
+                "Syntax: agentera verify eval skills [--run] [--runtime auto|opencode|cursor] [--format text|json]. " +
                 "Example: agentera verify eval skills --format json");
         }
         if ((args.parallel ?? 1) < 1 || (args.timeout ?? 120) < 1) {
@@ -63,7 +65,7 @@ export function validateVerifyRequest(args) {
         throw new Error("semantic verify requires explicit fixture path(s); broad fixture discovery is not a safe default. " +
             "Valid targets for eval: skills, semantic. " +
             "Syntax: agentera verify eval semantic <fixture> [<fixture>...] [--format text|json]. " +
-            "Example: agentera verify eval semantic fixtures/semantic/hej-bare-message.md --format json");
+            "Example: agentera verify eval semantic fixtures/semantic/bare-agentera-message.md --format json");
     }
     return [family, target, outputFormat];
 }
@@ -92,11 +94,11 @@ function runVerifyEngine(family, target, args) {
         }
         else {
             // Pin a concrete runtime for safe discovery unless explicitly chosen.
-            const dryRunRuntime = runtime !== "auto" ? runtime : "claude";
+            const dryRunRuntime = runtime !== "auto" ? runtime : "opencode";
             engineArgs.push("--parallel", parallel, "--timeout", timeout, "--runtime", dryRunRuntime, "--dry-run");
             safety = {
                 mode: "dry-run",
-                summary: "default lists skill prompts without invoking Claude Code, OpenCode, or long-running evals",
+                summary: "default lists skill prompts without invoking OpenCode, Cursor, or long-running evals",
                 live: false,
                 long_running_default: false,
             };
@@ -115,6 +117,20 @@ function runVerifyEngine(family, target, args) {
         const result = runInProcess(["eval", "semantic", ...fixtures], (out) => semanticEvalMain(fixtures, (l) => out(l)));
         return { result, safety };
     }
+    if (family === "eval" && target === "routing") {
+        const safety = {
+            mode: "offline-frozen-corpus",
+            summary: "runs the contract-owned frozen synthetic corpus only; it never sends requests or invokes a semantic host",
+            live: false,
+            long_running_default: false,
+        };
+        const result = runInProcess(["eval", "routing"], (out) => {
+            const report = evaluateHybridRoute();
+            out(JSON.stringify(report, null, 2) + "\n");
+            return routeEvaluationExitCode(report);
+        });
+        return { result, safety };
+    }
     throw new Error(`unhandled verify target ${family}/${target}`);
 }
 function runInProcess(command, invoke) {
@@ -207,4 +223,3 @@ export function cmdVerify(args, io = {}) {
     }
     return result.returncode;
 }
-//# sourceMappingURL=verify.js.map

package/dist/cli/contracts/bundleStatus.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/orientationState.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/dispatch/argvParser.js

@@ -0,0 +1,32 @@
+/** Shared argv flag helpers for dispatch-layer parsers. */
+/** Read `--flag` or `--flag=value` at argv[index]. */
+export function readArgvFlag(argv, index, name) {
+    const a = argv[index];
+    if (a === name)
+        return argv[index + 1] ?? null;
+    if (a.startsWith(name + "="))
+        return a.slice(name.length + 1);
+    return null;
+}
+/** True when argv[index] is `name` or `name=value`. */
+export function matchesArgvFlag(argv, index, name) {
+    const a = argv[index];
+    return a === name || a.startsWith(name + "=");
+}
+/**
+ * Factory matching the inline `value(name)` closures used across dispatch parsers.
+ * Space-separated values advance the outer loop index via setIndex.
+ */
+export function makeArgvValueReader(argv, getIndex, setIndex) {
+    return (name) => {
+        const i = getIndex();
+        const a = argv[i];
+        if (a === name) {
+            setIndex(i + 1);
+            return argv[i + 1] ?? null;
+        }
+        if (a.startsWith(name + "="))
+            return a.slice(name.length + 1);
+        return null;
+    };
+}

package/dist/cli/dispatch/check.js

@@ -1,22 +1,24 @@
 import { cmdLint } from "../commands/lint.js";
 import { cmdCompact } from "../commands/compact.js";
 import { cmdSchema } from "../commands/schema.js";
-import { cmdValidate, cmdValidateCapability, cmdValidateCapabilityContract, cmdValidateArtifact, cmdValidateDescriptors, isDelegatedValidateFamily, } from "../commands/validate.js";
-import { asEnvelopeFormat, classifyParseError } from "./shared.js";
+import { cmdValidate, cmdValidateCapability, cmdValidateCapabilityContract, cmdValidateArtifact, cmdValidateState, isDelegatedValidateFamily, VALIDATE_FAMILY_NAMES, cmdValidateActivationConjunction, } from "../commands/validate.js";
+import { makeArgvValueReader } from "./argvParser.js";
+import { asEnvelopeFormat, classifyParseError, detectTopLevelFormat } from "./shared.js";
 import { emitInvalidInput } from "../errors.js";
+import { StateWriteInputError } from "../../state/write/errors.js";
+import { cmdDurability, entityDurabilityFailure, emitDurabilityFailure, requestedDurabilityFormat, validateDurabilityArgs, } from "../commands/durability.js";
+import { resolveSourceRoot } from "../../core/sourceRoot.js";
+import { StateRetrievalFailure } from "../../state/directRetrieval.js";
 /** Minimal flag parser for the `lint` command surface. */
 export function parseLintArgs(argv) {
     const args = { artifact: "", file: null, text: null, strict: false, format: "text" };
     let sawArtifact = false;
-    for (let i = 0; i < argv.length; i++) {
+    let i = 0;
+    const value = makeArgvValueReader(argv, () => i, (n) => {
+        i = n;
+    });
+    for (; i < argv.length; i++) {
         const a = argv[i];
-        const value = (name) => {
-            if (a === name)
-                return argv[++i];
-            if (a.startsWith(name + "="))
-                return a.slice(name.length + 1);
-            return null;
-        };
         let v;
         if ((v = value("--artifact")) !== null) {
             args.artifact = v;
@@ -52,7 +54,7 @@ export function runLint(argv, io, prog = "agentera lint") {
     const parsed = parseLintArgs(argv);
     if ("error" in parsed) {
         return emitInvalidInput(io, {
-            format: "text",
+            format: detectTopLevelFormat(argv),
             body: classifyParseError(parsed.error),
         });
     }
@@ -79,15 +81,12 @@ export function compactModeOf(argv) {
 }
 export function parseCompactArgs(argv) {
     const args = { project: null, mode: "check", format: "text" };
-    for (let i = 0; i < argv.length; i++) {
+    let i = 0;
+    const value = makeArgvValueReader(argv, () => i, (n) => {
+        i = n;
+    });
+    for (; i < argv.length; i++) {
         const a = argv[i];
-        const value = (name) => {
-            if (a === name)
-                return argv[++i];
-            if (a.startsWith(name + "="))
-                return a.slice(name.length + 1);
-            return null;
-        };
         let v;
         if (a === "--apply") {
             args.mode = "fix";
@@ -123,13 +122,78 @@ export function runCompact(argv, io, prog) {
         return cmdCompact(parsed, io);
     }
     catch (exc) {
+        if (exc instanceof StateWriteInputError)
+            return emitInvalidInput(io, { format: asEnvelopeFormat(parsed.format), body: exc.body });
         return emitInvalidInput(io, {
             format: asEnvelopeFormat(parsed.format),
             body: { class: "unsupported_target", message: exc.message },
         });
     }
 }
+export function parseDurabilityArgs(argv) {
+    const args = { project: null, artifact: null, format: "text" };
+    let i = 0;
+    const value = makeArgvValueReader(argv, () => i, (n) => {
+        i = n;
+    });
+    for (; i < argv.length; i++) {
+        const token = argv[i];
+        let parsed;
+        if ((parsed = value("--project")) !== null)
+            args.project = parsed;
+        else if ((parsed = value("--artifact")) !== null)
+            args.artifact = parsed;
+        else if ((parsed = value("--id")) !== null)
+            args.id = parsed;
+        else if ((parsed = value("--number")) !== null) {
+            if (!/^[1-9][0-9]*$/.test(parsed))
+                return { error: `argument --number: invalid int value: '${parsed}'` };
+            const number = Number(parsed);
+            if (!Number.isSafeInteger(number))
+                return { error: `argument --number: invalid int value: '${parsed}'` };
+            args.number = number;
+        }
+        else if ((parsed = value("--limit")) !== null) {
+            if (!/^[1-9][0-9]*$/.test(parsed))
+                return { error: `argument --limit: invalid int value: '${parsed}'` };
+            const limit = Number(parsed);
+            if (!Number.isSafeInteger(limit))
+                return { error: `argument --limit: invalid int value: '${parsed}'` };
+            args.limit = limit;
+        }
+        else if ((parsed = value("--format")) !== null) {
+            if (parsed !== "text" && parsed !== "json" && parsed !== "yaml") {
+                return { error: `argument --format: invalid choice: '${parsed}' (choose from 'text', 'json', 'yaml')` };
+            }
+            args.format = parsed;
+        }
+        else
+            return { error: `unrecognized arguments: ${token}` };
+    }
+    if (args.number !== undefined && !args.artifact) {
+        return { error: "the following arguments are required: --artifact when --number is supplied" };
+    }
+    return args;
+}
+export function runDurability(argv, io, prog) {
+    const format = requestedDurabilityFormat(argv);
+    const sourceRoot = resolveSourceRoot();
+    const parsed = parseDurabilityArgs(argv);
+    if ("error" in parsed) {
+        return emitDurabilityFailure(entityDurabilityFailure(parsed.error), format, io);
+    }
+    try {
+        validateDurabilityArgs(parsed, sourceRoot);
+        return cmdDurability(parsed, io);
+    }
+    catch (exc) {
+        if (exc instanceof StateRetrievalFailure)
+            return emitDurabilityFailure(exc, format, io);
+        return emitDurabilityFailure(entityDurabilityFailure(exc.message, parsed.artifact, parsed.id ?? undefined), format, io);
+    }
+}
 export function runValidate(argv, io, prog) {
+    const requestedFormat = detectTopLevelFormat(argv);
     let family = null;
     let capabilityTarget = null;
     let artifactFlag = null;
@@ -177,7 +241,7 @@ export function runValidate(argv, io, prog) {
         }
         else if (a.startsWith("--")) {
             return emitInvalidInput(io, {
-                format,
+                format: requestedFormat,
                 body: {
                     class: "unrecognized_argument",
                     message: `unrecognized arguments: ${a}`,
@@ -192,7 +256,7 @@ export function runValidate(argv, io, prog) {
         }
         else {
             return emitInvalidInput(io, {
-                format,
+                format: requestedFormat,
                 body: {
                     class: "unrecognized_argument",
                     message: `unrecognized arguments: ${a}`,
@@ -206,18 +270,7 @@ export function runValidate(argv, io, prog) {
             body: {
                 class: "missing_argument",
                 message: "the following arguments are required: validate_family",
-                valid_values: [
-                    "cross-capability",
-                    "lifecycle-adapters",
-                    "app-home-contract",
-                    "vocabularyAuthority",
-                    "selfAudit",
-                    "release-metadata",
-                    "capability",
-                    "capability-contract",
-                    "descriptors",
-                    "artifact",
-                ],
+                valid_values: [...VALIDATE_FAMILY_NAMES],
                 example: "agentera check validate cross-capability",
             },
         });
@@ -230,7 +283,7 @@ export function runValidate(argv, io, prog) {
                     body: {
                         class: "missing_argument",
                         message: "the following arguments are required: target",
-                        example: "agentera check validate capability planera",
+                        example: "agentera check validate capability plan",
                     },
                 });
             }
@@ -239,8 +292,8 @@ export function runValidate(argv, io, prog) {
         if (family === "capability-contract") {
             return cmdValidateCapabilityContract({ format }, io);
         }
-        if (family === "descriptors") {
-            return cmdValidateDescriptors({ format }, io);
+        if (family === "activation-conjunction") {
+            return cmdValidateActivationConjunction(io);
         }
         if (family === "artifact") {
             if (artifactFlag === null) {
@@ -255,6 +308,9 @@ export function runValidate(argv, io, prog) {
             }
             return cmdValidateArtifact({ artifact: artifactFlag, file: fileFlag, cwd: cwdFlag, format }, io);
         }
+        if (family === "state") {
+            return cmdValidateState({ cwd: cwdFlag, format }, io);
+        }
         if (isDelegatedValidateFamily(family)) {
             return cmdValidate(family, { format }, io);
         }
@@ -262,19 +318,8 @@ export function runValidate(argv, io, prog) {
             format,
             body: {
                 class: "unsupported_target",
-                message: `validate family not yet ported: ${family}`,
-                valid_values: [
-                    "cross-capability",
-                    "lifecycle-adapters",
-                    "app-home-contract",
-                    "vocabularyAuthority",
-                    "selfAudit",
-                    "release-metadata",
-                    "capability",
-                    "capability-contract",
-                    "descriptors",
-                    "artifact",
-                ],
+                message: `unsupported validate family '${family}'; valid families are listed in valid_values.`,
+                valid_values: [...VALIDATE_FAMILY_NAMES],
             },
         });
     }
@@ -325,4 +370,3 @@ export function runSchema(argv, io, prog) {
         });
     }
 }
-//# sourceMappingURL=check.js.map

package/dist/cli/dispatch/commands.js

@@ -0,0 +1,27 @@
+import { CAPABILITY_ROUTING_NAMES } from "../commands/capability.js";
+import { DIAGNOSTIC_TOP_LEVEL_COMMANDS } from "./projections.js";
+/**
+ * Top-level commands routed by `dispatch/main` (includes migration aliases still
+ * accepted at the CLI surface).
+ */
+export const DISPATCHER_TOP_LEVEL_COMMANDS = [
+    "prime",
+    "app-home",
+    "doctor",
+    "usage",
+    "upgrade",
+    "verify",
+    "report",
+    "stats",
+    "schema",
+    "lint",
+    "check",
+    "state",
+    "query",
+    "compact",
+    "validate",
+    "route",
+    ...CAPABILITY_ROUTING_NAMES,
+];
+/** Set view for doctor in-process CLI probe checks. */
+export const DISPATCHER_COMMANDS = new Set(DIAGNOSTIC_TOP_LEVEL_COMMANDS);

package/dist/cli/dispatch/index.js

@@ -1,12 +1,18 @@
-import { isPortedStateCommand } from "../commands/state/index.js";
 import { CAPABILITY_ROUTING_NAMES } from "../commands/capability.js";
-import { printCommandHelp, printTopLevelHelp, splitHelpArgs } from "../help.js";
-import { compactModeOf, runCompact, runLint, runSchema, runValidate } from "./check.js";
+import { runRouteEvaluation, runRouteReceipt, runRouteRequest } from "../commands/route.js";
+import { preCutoverCommand } from "../preCutoverCommand.js";
+import { printCommandHelp, printStateHelp, printTopLevelHelp, splitHelpArgs, stateCommandNames, } from "../help.js";
+import { compactModeOf, runCompact, runDurability, runLint, runSchema, runValidate, } from "./check.js";
 import { runQuery, runState } from "./state.js";
+import { entityListFamily } from "../../state/entityRetrievalHelp.js";
+import { ENTITY_LIST_RUNTIME_FAMILIES, runtimeEntityFamiliesForCommand } from "../../state/entityListRuntimeRegistry.js";
 import { runCapability, runPrime } from "./prime.js";
-import { runDoctor, runGate, runHook, runReport, runUpgrade, runUsage, runVerify } from "./lifecycle.js";
-import { emitDeprecationAlias } from "./shared.js";
+import { runAppHome, runDoctor, runGate, runReport, runUpgrade, runUsage, runVerify, runVersion, } from "./lifecycle.js";
+import { detectTopLevelFormat, emitDeprecationAlias } from "./shared.js";
 import { emitInvalidInput } from "../errors.js";
+import { verbsForArtifact } from "../../state/write/operations.js";
+import { REMOVED_TOP_LEVEL_CORRECTIONS } from "../commands/schema.js";
+import { enforceCompletedEntityCutover, migrationProject, requestedMigrationFailureFormat, requiresCompletedEntityCutover, } from "../migrationRequired.js";
 export function main(argv, io = {}) {
     const err = io.err ?? ((t) => process.stderr.write(t));
     const out = io.out ?? ((t) => process.stdout.write(t));
@@ -31,9 +37,44 @@ export function main(argv, io = {}) {
             },
         });
     }
+    if (command && REMOVED_TOP_LEVEL_CORRECTIONS[command]) {
+        const canonical = REMOVED_TOP_LEVEL_CORRECTIONS[command];
+        const canonicalTokens = canonical.split(" ");
+        const runtimeFamily = canonicalTokens[0] === "state"
+            ? ENTITY_LIST_RUNTIME_FAMILIES.find(({ commandTokens }) => commandTokens.join(" ") === canonicalTokens.slice(1).join(" "))
+            : undefined;
+        const family = runtimeFamily ? entityListFamily(runtimeFamily.key) : undefined;
+        const example = family
+            ? family.bareRecovery ?? `agentera state ${family.commandTokens.join(" ")} list --limit ${family.bounds.default} --format json`
+            : `agentera ${canonical} --format json`;
+        return emitInvalidInput(io, {
+            format: detectTopLevelFormat(rest),
+            body: {
+                class: "unsupported_target",
+                message: `unknown or not-yet-ported command: ${command}; this top-level name was removed, use '${canonical}'`,
+                valid_values: [canonical],
+                syntax: `agentera ${canonical} [options]`,
+                example,
+                recovery: `Run ${example}; no state was changed by the rejected command.`,
+            },
+        });
+    }
+    // Retained-reference validation audits package source, not project state. It
+    // must report its source-checkout boundary before project migration checks.
+    const sourceOnlyReferenceValidation = args[0] === "check" && args[1] === "validate" && ["retained-references", "activation-conjunction"].includes(args[2] ?? "");
+    if (!sourceOnlyReferenceValidation && requiresCompletedEntityCutover(args)) {
+        const failure = enforceCompletedEntityCutover(migrationProject(args), requestedMigrationFailureFormat(args), io, args);
+        if (failure !== null)
+            return failure;
+    }
     switch (command) {
+        case "--version":
+        case "version":
+            return runVersion(rest, io);
         case "prime":
             return runPrime("prime", rest, io, "agentera prime");
+        case "app-home":
+            return runAppHome(rest, io, "agentera app-home");
         case "doctor":
             return runDoctor(rest, io, "agentera doctor");
         case "usage":
@@ -48,26 +89,6 @@ export function main(argv, io = {}) {
         case "stats":
             emitDeprecationAlias("stats", "report", err);
             return runReport(rest, io, "agentera stats");
-        case "hook": {
-            const name = rest[0];
-            if (!name) {
-                return emitInvalidInput(io, {
-                    format: "text",
-                    body: {
-                        class: "missing_argument",
-                        message: "the following arguments are required: hook_name",
-                        valid_values: [
-                            "session-start",
-                            "session-stop",
-                            "cursor-session-start",
-                            "cursor-pre-tool-use",
-                            "validate-artifact",
-                        ],
-                    },
-                });
-            }
-            return runHook(name, rest.slice(1), io);
-        }
         case "schema":
             return runSchema(rest, io, "agentera schema");
         case "lint":
@@ -81,7 +102,7 @@ export function main(argv, io = {}) {
                     body: {
                         class: "missing_argument",
                         message: "the following arguments are required: check_command",
-                        valid_values: ["validate", "verify", "lint", "compact"],
+                        valid_values: ["validate", "verify", "lint", "compact", "durability"],
                     },
                 });
             }
@@ -89,6 +110,8 @@ export function main(argv, io = {}) {
                 return runValidate(rest.slice(1), io, "agentera check validate");
             if (sub === "verify")
                 return runVerify(rest.slice(1), io, "agentera check verify");
+            if (sub === "durability")
+                return runDurability(rest.slice(1), io, "agentera check durability");
             if (sub === "lint")
                 return runLint(rest.slice(1), io, "agentera check lint");
             if (sub === "compact") {
@@ -103,61 +126,69 @@ export function main(argv, io = {}) {
                 body: {
                     class: "unsupported_target",
                     message: `unknown or not-yet-ported check subcommand: ${sub}`,
-                    valid_values: ["validate", "verify", "lint", "compact"],
+                    valid_values: ["validate", "verify", "lint", "compact", "durability"],
                 },
             });
         }
         case "state": {
             const sub = rest[0];
+            const stateCommands = stateCommandNames();
+            const stateSyntax = printStateHelp()
+                .split("\n", 1)[0]
+                .replace(/^usage:\s*/, "");
+            const stateExample = "agentera state progress list --format json";
             if (!sub) {
                 return emitInvalidInput(io, {
                     format: "text",
                     body: {
                         class: "missing_argument",
                         message: "the following arguments are required: state_command",
-                        valid_values: [
-                            "progress",
-                            "plan",
-                            "health",
-                            "docs",
-                            "objective",
-                            "experiments",
-                            "todo",
-                            "decisions",
-                            "query",
-                        ],
+                        valid_values: stateCommands,
+                        syntax: stateSyntax,
+                        example: stateExample,
                     },
                 });
             }
             if (sub === "query")
                 return runQuery(rest.slice(1), io, "agentera state query");
-            if (isPortedStateCommand(sub))
+            if (runtimeEntityFamiliesForCommand(sub).length > 0 || verbsForArtifact(sub).some((verb) => verb === rest[1]))
                 return runState(sub, rest.slice(1), io, `agentera state ${sub}`);
             return emitInvalidInput(io, {
                 format: "text",
                 body: {
                     class: "unsupported_target",
                     message: `unknown or not-yet-ported state subcommand: ${sub}`,
-                    valid_values: [
-                        "progress",
-                        "plan",
-                        "health",
-                        "docs",
-                        "objective",
-                        "experiments",
-                        "todo",
-                        "decisions",
-                        "query",
-                    ],
+                    valid_values: stateCommands,
+                    syntax: stateSyntax,
+                    example: stateExample,
                 },
             });
         }
         case "query":
             emitDeprecationAlias("query", "state query", err);
             return runQuery(rest, io, "agentera query");
+        case "route":
+            if (rest[0] === "request")
+                return runRouteRequest(rest.slice(1), io);
+            if (rest[0] === "receipt")
+                return runRouteReceipt(rest.slice(1), io);
+            if (rest[0] === "evaluate")
+                return runRouteEvaluation(rest.slice(1), io);
+            return emitInvalidInput(io, {
+                format: detectTopLevelFormat(rest),
+                body: {
+                    class: "unsupported_target",
+                    message: "route requires the request subcommand",
+                    valid_values: ["request", "receipt", "evaluate"],
+                    syntax: `${preCutoverCommand("route <request|receipt> --input PATH --format json")} | ${preCutoverCommand("route evaluate --format json")}`,
+                    example: preCutoverCommand("route receipt --input - --format json"),
+                },
+            });
         case "compact":
             emitDeprecationAlias("compact", "check compact", err);
-            return runCompact(rest, io, "agentera compact");
+            return compactModeOf(rest) === "fix"
+                ? runCompact(rest, io, "agentera compact")
+                : runGate(rest, io, "agentera compact");
         case "validate":
             emitDeprecationAlias("validate", "check validate", err);
             return runValidate(rest, io, "agentera validate");
@@ -174,4 +205,3 @@ export function main(argv, io = {}) {
             });
     }
 }
-//# sourceMappingURL=index.js.map