taphound 0.2.0-dev.1 → 0.2.0-dev.11

package/dist/cli/commands/align.js

@@ -0,0 +1,124 @@
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { TapHoundConfigSchema } from "../../domain/config.js";
+import { assertArtifactDirectory, CONFIG_PATH } from "../../domain/workspace.js";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../../domain/failure.js";
+import { AlignError } from "../../application/align/align-service.js";
+import { AlignPromptCancelledError } from "../../ports/align-prompt.js";
+import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+import { prepareWorkspace } from "../workspace-guard.js";
+function alignCameraText(result) {
+    if (result.status === "cancelled") {
+        return "Cancelled — no flow written.";
+    }
+    const { flow, probe } = result;
+    const confirmLine = probe.confirmResourceId !== undefined
+        ? `  Confirm button:    ${probe.confirmResourceId}`
+        : "  Confirm button:    (none — camera auto-accepts)";
+    const reviewActivityLine = probe.confirmActivityName === undefined
+        ? []
+        : [`  Review activity:   ${probe.confirmActivityName}`];
+    return [
+        "Probing camera...",
+        `  Camera package:    ${probe.packageName}`,
+        `  Camera activity:   ${probe.activityName}`,
+        ...reviewActivityLine,
+        `  Shutter button:    ${probe.shutterResourceId}`,
+        confirmLine,
+        "",
+        `Wrote ${flow.name} flow (${String(flow.steps)} steps)`,
+        `  Path: ${flow.path}`
+    ].join("\n");
+}
+export function createAlignCommand(dependencies) {
+    const align = new Command("align")
+        .description("Align device-specific External Flows");
+    align
+        .command("camera")
+        .description("Probe the device camera and write a project External Flow")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--config <path>", "TapHound config path", CONFIG_PATH)
+        .option("--device <serial>", "Select an online Android device")
+        .option("--force", "Overwrite an existing project flow")
+        .option("--json", "Emit machine-readable JSON")
+        .action(async (options) => {
+        try {
+            try {
+                const config = await TapHoundConfigSchema.parseAsync(await dependencies.readJson(resolve(options.project, options.config)));
+                assertArtifactDirectory(options.project, config.artifactsDir);
+                await prepareWorkspace(dependencies, options.project);
+            }
+            catch (error) {
+                const output = failureOutput(2, "CONFIG_INVALID", errorMessage(error));
+                if (options.json === true) {
+                    writeJson(dependencies.stdout, output);
+                }
+                else {
+                    writeLine(dependencies.stderr, output.failure.message);
+                }
+                dependencies.setExitCode(2);
+                return;
+            }
+            const result = await dependencies.align.alignCamera({
+                projectRoot: options.project,
+                ...(options.device === undefined ? {} : { deviceSerial: options.device }),
+                ...(options.force === undefined ? {} : { force: options.force }),
+                json: options.json === true,
+                ...(dependencies.signal === undefined ? {} : { signal: dependencies.signal })
+            });
+            if (options.json === true) {
+                writeJson(dependencies.stdout, result);
+            }
+            else {
+                writeLine(dependencies.stdout, alignCameraText(result));
+            }
+            dependencies.setExitCode(result.exitCode);
+        }
+        catch (error) {
+            if (error instanceof AlignPromptCancelledError) {
+                const cancelled = { status: "cancelled", exitCode: 2 };
+                if (options.json === true) {
+                    writeJson(dependencies.stdout, cancelled);
+                }
+                else {
+                    writeLine(dependencies.stdout, alignCameraText(cancelled));
+                }
+                dependencies.setExitCode(2);
+                return;
+            }
+            if (error instanceof AlignError) {
+                const output = failureOutput(2, error.code, error.message);
+                if (options.json === true) {
+                    writeJson(dependencies.stdout, output);
+                }
+                else {
+                    writeLine(dependencies.stderr, output.failure.message);
+                }
+                dependencies.setExitCode(2);
+                return;
+            }
+            const failureCode = failureCodeFromUnknown(error);
+            if (failureCode !== undefined) {
+                const exitCode = exitCodeForFailure(failureCode);
+                const output = failureOutput(exitCode, failureCode, errorMessage(error));
+                if (options.json === true) {
+                    writeJson(dependencies.stdout, output);
+                }
+                else {
+                    writeLine(dependencies.stderr, output.failure.message);
+                }
+                dependencies.setExitCode(exitCode);
+                return;
+            }
+            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(4);
+        }
+    });
+    return align;
+}

package/dist/cli/commands/baseline.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliDependencies } from "../dependencies.js";
+export declare function createBaselineCommand(dependencies: CliDependencies): Command;

package/dist/cli/commands/baseline.js

@@ -0,0 +1,130 @@
+import { Command } from "commander";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../../domain/failure.js";
+import { BASELINES_DIR, BUILD_DIR, assertProjectPathUnder } from "../../domain/workspace.js";
+import { failureOutput, writeJson, writeLine } from "../output.js";
+import { prepareWorkspace } from "../workspace-guard.js";
+function writeFailure(dependencies, json, code, message) {
+    const exitCode = exitCodeForFailure(code);
+    const output = failureOutput(exitCode, code, message);
+    if (json) {
+        writeJson(dependencies.stdout, output);
+    }
+    else {
+        writeLine(dependencies.stderr, output.failure.message);
+    }
+    dependencies.setExitCode(exitCode);
+}
+export function createBaselineCommand(dependencies) {
+    const command = new Command("baseline")
+        .description("Capture and compare behavior Baselines against Verification reports")
+        .addCommand(createCaptureCommand(dependencies))
+        .addCommand(createCompareCommand(dependencies));
+    return command;
+}
+function createCaptureCommand(dependencies) {
+    return new Command("capture")
+        .description("Capture a Baseline from a passing Verification report (offline)")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .requiredOption("--report <path>", "Verification report.json path")
+        .option("--id <name>", "Baseline id (defaults to the report runId)")
+        .option("--journey-sha256 <sha256>", "Assert the source report's Journey sha256")
+        .option("--contract-sha256 <sha256>", "Assert the passing Verdict's Contract sha256")
+        .option("--verdict <path>", "Passing Contract verdict.json for the source report")
+        .option("--no-screen-facts", "Exclude Screen facts from this Baseline")
+        .requiredOption("--out <path>", "Baseline output under .taphound/baselines")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        const json = options.json === true;
+        if (dependencies.baselineService === undefined) {
+            writeFailure(dependencies, json, "CONFIG_INVALID", "TapHound baseline capture is not configured");
+            return;
+        }
+        try {
+            await prepareWorkspace(dependencies, options.project);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONFIG_INVALID", error instanceof Error ? error.message : String(error));
+            return;
+        }
+        try {
+            const reportPath = assertProjectPathUnder(options.project, options.report, BUILD_DIR, "Verification report");
+            const verdictPath = options.verdict === undefined
+                ? undefined
+                : assertProjectPathUnder(options.project, options.verdict, BUILD_DIR, "Contract verdict");
+            const outputPath = assertProjectPathUnder(options.project, options.out, BASELINES_DIR, "Baseline output");
+            const baseline = await dependencies.baselineService.captureFromReport(reportPath, {
+                id: options.id,
+                journeySha256: options.journeySha256,
+                contractSha256: options.contractSha256,
+                ...(verdictPath === undefined ? {} : { verdictPath }),
+                includeScreenFacts: options.screenFacts
+            });
+            await dependencies.baselineService.write({
+                path: outputPath,
+                baseline
+            });
+            if (json) {
+                writeJson(dependencies.stdout, baseline);
+            }
+            else {
+                writeLine(dependencies.stdout, `Baseline ${baseline.id} captured (${String(baseline.activities.length)} activity facts, ${String(baseline.elements.length)} element facts, ${String(baseline.checkpoints?.length ?? 0)} Checkpoint facts)`);
+            }
+            dependencies.setExitCode(0);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONFIG_INVALID", error instanceof Error ? error.message : String(error));
+        }
+    });
+}
+function createCompareCommand(dependencies) {
+    return new Command("compare")
+        .description("Compare a Verification report against a stored Baseline")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .requiredOption("--baseline <path>", "Baseline JSON path")
+        .requiredOption("--report <path>", "Verification report.json path")
+        .option("--journey-sha256 <sha256>", "Assert the current report's Journey sha256")
+        .option("--verdict <path>", "Contract verdict.json for this report (defaults beside report.json)")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        const json = options.json === true;
+        if (dependencies.baselineService === undefined) {
+            writeFailure(dependencies, json, "CONFIG_INVALID", "TapHound regression comparison is not configured");
+            return;
+        }
+        try {
+            await prepareWorkspace(dependencies, options.project);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONFIG_INVALID", error instanceof Error ? error.message : String(error));
+            return;
+        }
+        try {
+            const baselinePath = assertProjectPathUnder(options.project, options.baseline, BASELINES_DIR, "Baseline");
+            const reportPath = assertProjectPathUnder(options.project, options.report, BUILD_DIR, "Verification report");
+            const verdictPath = options.verdict === undefined
+                ? undefined
+                : assertProjectPathUnder(options.project, options.verdict, BUILD_DIR, "Contract verdict");
+            const result = await dependencies.baselineService.compare({
+                baselinePath,
+                reportPath,
+                journeySha256: options.journeySha256,
+                ...(verdictPath === undefined ? {} : { verdictPath })
+            });
+            if (json) {
+                writeJson(dependencies.stdout, result);
+            }
+            else {
+                writeLine(dependencies.stdout, result.equivalent
+                    ? `Regression compare: equivalent (${String(result.regressions.length)} diffs)`
+                    : `Regression compare: ${String(result.regressions.length)} diff(s)`);
+                for (const diff of result.regressions) {
+                    writeLine(dependencies.stdout, `- ${diff.kind}${diff.checkpointId === undefined ? "" : ` checkpoint=${diff.checkpointId}`}${diff.stepIndex === undefined ? "" : ` step=${String(diff.stepIndex)}`}: expected ${diff.expected}, actual ${diff.actual}`);
+                }
+            }
+            dependencies.setExitCode(result.equivalent ? 0 : 1);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONFIG_INVALID", error instanceof Error ? error.message : String(error));
+        }
+    });
+}

package/dist/cli/commands/context.js

@@ -1,32 +1,74 @@
 import { resolve } from "node:path";
 import { Command } from "commander";
+import { ContextGenerateError } from "../../application/context/context-generator.js";
+import { ContextLoadError } from "../../application/context/context-loader.js";
+import { ContextRehashError } from "../../application/context/context-rehasher.js";
+import { ContextRefreshError } from "../../application/context/context-refresher.js";
 import { TapHoundConfigSchema } from "../../domain/config.js";
-import { ProjectContextSchema } from "../../domain/project-context.js";
+import { assertProjectPathUnder, CONFIG_PATH, CONTEXT_DIR } from "../../domain/workspace.js";
 import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+function contextPath(root, requested) {
+    return assertProjectPathUnder(root, requested, CONTEXT_DIR, "Project Context output");
+}
 function exitCodeForContext(command, result) {
     if (result.status === "invalid") {
         return 2;
     }
     return command === "validate" && result.status === "stale" ? 1 : 0;
 }
+function loadFailureResult(error) {
+    return error.code === "CONTEXT_STALE"
+        ? {
+            status: "stale",
+            reason: {
+                code: "EVIDENCE_HASH_MISMATCH",
+                message: error.message
+            }
+        }
+        : {
+            status: "invalid",
+            reason: {
+                code: "CONTEXT_SCHEMA_INVALID",
+                message: error.message
+            }
+        };
+}
+function writeContextResult(dependencies, options, name, result, details = {}) {
+    const exitCode = exitCodeForContext(name, result);
+    const output = { ...result, ...details, exitCode };
+    if (options.json === true) {
+        writeJson(dependencies.stdout, output);
+    }
+    else {
+        writeLine(dependencies.stdout, result.status === "valid"
+            ? "Context: valid"
+            : `Context: ${result.status} (${result.reason.message})`);
+        if (result.status === "valid" && result.divergence !== undefined) {
+            writeLine(dependencies.stderr, `identity divergence: evidence package ${result.divergence.evidencePackageName}, configured package ${result.divergence.configuredPackageName} (activity suffix matches)`);
+        }
+    }
+    dependencies.setExitCode(exitCode);
+}
 function createContextOperation(dependencies, name) {
     return new Command(name)
         .description(name === "validate"
         ? "Validate deterministic Project Context evidence"
         : "Observe deterministic Project Context status")
         .option("--project <path>", "Android project root", dependencies.cwd())
-        .option("--config <path>", "TapHound config path", "taphound.config.json")
-        .requiredOption("--context <path>", "Project Context path")
+        .option("--config <path>", "TapHound config path", CONFIG_PATH)
+        .option("--context <path>", "Project Context path under .taphound/context", ".taphound/context/project-context.json")
+        .option("--module <id...>", "Select Context modules")
         .option("--json", "Emit one machine-readable JSON value")
         .action(async (options) => {
+        const json = options.json === true;
+        const projectRoot = options.project;
         let config;
-        let context;
         try {
-            config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
+            config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(projectRoot, options.config)));
         }
         catch (error) {
             const output = failureOutput(2, "CONFIG_INVALID", errorMessage(error));
-            if (options.json === true) {
+            if (json) {
                 writeJson(dependencies.stdout, output);
             }
             else {
@@ -36,53 +78,280 @@ function createContextOperation(dependencies, name) {
             return;
         }
         try {
-            context = ProjectContextSchema.parse(await dependencies.readJson(resolve(options.project, options.context)));
+            const loaded = await dependencies.contextLoader.load({
+                projectRoot,
+                contextPath: contextPath(projectRoot, options.context),
+                ...(options.module === undefined ? {} : { moduleIds: options.module }),
+                allowIncomplete: name === "status"
+            });
+            const result = await dependencies.contextValidator.validate({
+                context: loaded.context,
+                projectRoot,
+                config,
+                ...(name === "status" ? { modules: loaded.modules } : {}),
+                ...(name === "status" ? { reportScopes: true } : {})
+            });
+            writeContextResult(dependencies, options, name, result, {
+                contextSelection: loaded.context.selection,
+                modules: loaded.modules.map((module) => ({
+                    id: module.moduleId,
+                    status: module.status
+                }))
+            });
         }
         catch (error) {
+            if (error instanceof ContextLoadError) {
+                writeContextResult(dependencies, options, name, loadFailureResult(error));
+                return;
+            }
+            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(4);
+        }
+    });
+}
+function createContextListCommand(dependencies) {
+    return new Command("list")
+        .description("List Project Context modules without loading shards")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--context <path>", "Project Context path under .taphound/context", ".taphound/context/project-context.json")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        try {
+            const { bundle, indexHash } = await dependencies.contextLoader.readIndex({
+                projectRoot: options.project,
+                contextPath: contextPath(options.project, options.context)
+            });
             const output = {
-                status: "error",
-                exitCode: 2,
-                failure: {
-                    code: "CONTEXT_INVALID",
-                    message: errorMessage(error)
-                }
+                status: "listed",
+                exitCode: 0,
+                version: bundle.version,
+                packageName: bundle.packageName,
+                launchActivity: bundle.launchActivity,
+                indexHash,
+                modules: bundle.modules
             };
             if (options.json === true) {
                 writeJson(dependencies.stdout, output);
             }
+            else {
+                for (const module of bundle.modules) {
+                    writeLine(dependencies.stdout, `${module.id}: ${module.status} (${module.contextPath})`);
+                }
+            }
+            dependencies.setExitCode(0);
+        }
+        catch (error) {
+            const output = error instanceof ContextLoadError
+                ? {
+                    status: "error",
+                    exitCode: 2,
+                    failure: {
+                        code: error.code,
+                        message: error.message
+                    }
+                }
+                : failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
             else {
                 writeLine(dependencies.stderr, output.failure.message);
             }
-            dependencies.setExitCode(2);
-            return;
+            dependencies.setExitCode(output.exitCode);
+        }
+    });
+}
+function refreshExitCode(result) {
+    return result.status === "blocked" ? 1 : 0;
+}
+function writeRefreshText(dependencies, result) {
+    writeLine(dependencies.stdout, `Context: ${result.status}`);
+    for (const scope of result.scopes) {
+        if (scope.semanticBackfilled === 0
+            && scope.formattingRehashed === 0
+            && scope.semanticChanged.length === 0
+            && scope.unresolved.length === 0
+            && scope.pruned === 0
+            && scope.droppedIneligible === 0
+            && !scope.inventoryChanged) {
+            continue;
         }
+        writeLine(dependencies.stdout, `${scope.id}: semantic ${String(scope.semanticBackfilled)}`
+            + `, rehashed ${String(scope.formattingRehashed)}`
+            + `, changed ${String(scope.semanticChanged.length)}`
+            + `, unresolved ${String(scope.unresolved.length)}`
+            + `, pruned ${String(scope.pruned)}`
+            + `, dropped ${String(scope.droppedIneligible)}`
+            + (scope.inventoryChanged ? ", inventory changed" : ""));
+    }
+    for (const block of result.blocked) {
+        writeLine(dependencies.stderr, `${block.code} [${block.resolution}]: ${block.message}`);
+    }
+}
+function createContextRefreshCommand(dependencies) {
+    return new Command("refresh")
+        .description("Recompute Project Context evidence hashes without analysis")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--context <path>", "Project Context path under .taphound/context", ".taphound/context/project-context.json")
+        .option("--module <id...>", "Refresh only the listed Context modules")
+        .option("--accept-source-changes", "Also rehash evidence whose semantics changed")
+        .option("--prune-deleted", "Drop evidence entries for files no longer on disk")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
         try {
-            const result = await dependencies.contextValidator.validate({
-                context,
+            const result = await dependencies.contextRefresher.refresh({
                 projectRoot: options.project,
-                config
+                contextPath: contextPath(options.project, options.context),
+                ...(options.module === undefined ? {} : { moduleIds: options.module }),
+                ...(options.acceptSourceChanges === undefined
+                    ? {}
+                    : { acceptSourceChanges: options.acceptSourceChanges }),
+                ...(options.pruneDeleted === undefined
+                    ? {}
+                    : { pruneDeleted: options.pruneDeleted })
             });
-            const exitCode = exitCodeForContext(name, result);
-            const output = { ...result, exitCode };
+            const exitCode = refreshExitCode(result);
             if (options.json === true) {
-                writeJson(dependencies.stdout, output);
+                writeJson(dependencies.stdout, { ...result, exitCode });
             }
             else {
-                writeLine(dependencies.stdout, result.status === "valid"
-                    ? "Context: valid"
-                    : `Context: ${result.status} (${result.reason.message})`);
+                writeRefreshText(dependencies, result);
             }
             dependencies.setExitCode(exitCode);
         }
         catch (error) {
-            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            const output = error instanceof ContextRefreshError
+                ? {
+                    status: "error",
+                    exitCode: 2,
+                    failure: { code: error.code, message: error.message }
+                }
+                : error instanceof ContextLoadError
+                    ? {
+                        status: "error",
+                        exitCode: 2,
+                        failure: { code: error.code, message: error.message }
+                    }
+                    : failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
             if (options.json === true) {
                 writeJson(dependencies.stdout, output);
             }
             else {
                 writeLine(dependencies.stderr, output.failure.message);
             }
-            dependencies.setExitCode(4);
+            dependencies.setExitCode(output.exitCode);
+        }
+    });
+}
+function writeGenerateText(dependencies, result) {
+    writeLine(dependencies.stdout, `Context: generated (${String(result.modules.length)} modules)`);
+    writeLine(dependencies.stdout, `Package: ${result.packageName}`);
+    writeLine(dependencies.stdout, `Activity: ${result.launchActivity}`);
+    for (const module of result.modules) {
+        writeLine(dependencies.stdout, `  ${module.id}: ${module.kind} (${String(module.evidenceCount)} evidence files)`);
+    }
+}
+function createContextGenerateCommand(dependencies) {
+    return new Command("generate")
+        .description("Generate Project Context scaffolding from project source")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--context <path>", "Project Context path under .taphound/context", ".taphound/context/project-context.json")
+        .option("--force", "Overwrite an existing Project Context")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        const json = options.json === true;
+        const projectRoot = options.project;
+        try {
+            const result = await dependencies.contextGenerator.generate({
+                projectRoot,
+                contextPath: contextPath(projectRoot, options.context),
+                ...(options.force === undefined ? {} : { force: options.force })
+            });
+            const output = { ...result, exitCode: 0 };
+            if (json) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeGenerateText(dependencies, result);
+            }
+            dependencies.setExitCode(0);
+        }
+        catch (error) {
+            const output = error instanceof ContextGenerateError
+                ? {
+                    status: "error",
+                    exitCode: 2,
+                    failure: { code: error.code, message: error.message }
+                }
+                : failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (json) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(output.exitCode);
+        }
+    });
+}
+function writeRehashText(dependencies, result) {
+    writeLine(dependencies.stdout, `Context: ${result.status}`);
+    for (const module of result.modules) {
+        if (module.changed) {
+            writeLine(dependencies.stdout, `  ${module.id}: ${module.previousSha256} -> ${module.currentSha256}`);
+        }
+    }
+}
+function createContextRehashCommand(dependencies) {
+    return new Command("rehash")
+        .description("Recompute Project Context shard and index hashes")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--context <path>", "Project Context path under .taphound/context", ".taphound/context/project-context.json")
+        .option("--module <id...>", "Rehash only the listed Context modules")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        try {
+            const result = await dependencies.contextRehasher.rehash({
+                projectRoot: options.project,
+                contextPath: contextPath(options.project, options.context),
+                ...(options.module === undefined ? {} : { moduleIds: options.module })
+            });
+            const output = { ...result, exitCode: 0 };
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeRehashText(dependencies, result);
+            }
+            dependencies.setExitCode(0);
+        }
+        catch (error) {
+            const output = error instanceof ContextRehashError
+                ? {
+                    status: "error",
+                    exitCode: 2,
+                    failure: { code: error.code, message: error.message }
+                }
+                : error instanceof ContextLoadError
+                    ? {
+                        status: "error",
+                        exitCode: 2,
+                        failure: { code: error.code, message: error.message }
+                    }
+                    : failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(output.exitCode);
         }
     });
 }
@@ -90,5 +359,9 @@ export function createContextCommand(dependencies) {
     return new Command("context")
         .description("Validate or inspect Project Context")
         .addCommand(createContextOperation(dependencies, "validate"))
-        .addCommand(createContextOperation(dependencies, "status"));
+        .addCommand(createContextOperation(dependencies, "status"))
+        .addCommand(createContextListCommand(dependencies))
+        .addCommand(createContextRefreshCommand(dependencies))
+        .addCommand(createContextGenerateCommand(dependencies))
+        .addCommand(createContextRehashCommand(dependencies));
 }

package/dist/cli/commands/contract.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliDependencies } from "../dependencies.js";
+export declare function createContractCommand(dependencies: CliDependencies): Command;