taphound 0.2.0-dev.1 → 0.2.0-dev.12

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;

package/dist/cli/commands/contract.js

@@ -0,0 +1,120 @@
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../../domain/failure.js";
+import { ContractReviewInputSchema, ContractVerdictViewSchema } from "../../domain/contract.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 createContractCommand(dependencies) {
+    const command = new Command("contract")
+        .description("Validate an Acceptance Contract without touching a device")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--contract <path>", "Acceptance Contract path")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        const json = options.json === true;
+        if (options.contract === undefined) {
+            writeFailure(dependencies, json, "CONTRACT_INVALID", "Missing required option '--contract'");
+            return;
+        }
+        if (dependencies.contractLoader === undefined) {
+            writeFailure(dependencies, json, "CONFIG_INVALID", "TapHound contract validation is not configured");
+            return;
+        }
+        const contractPath = resolve(options.project, options.contract);
+        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 loaded = await dependencies.contractLoader.load({
+                projectRoot: options.project,
+                contractPath
+            });
+            if (json) {
+                writeJson(dependencies.stdout, {
+                    status: "valid",
+                    contractId: loaded.contract.id,
+                    contractSha256: loaded.contractSha256,
+                    journeySha256: loaded.contract.journey.sha256,
+                    journeyPath: loaded.journeyPath
+                });
+            }
+            else {
+                writeLine(dependencies.stdout, `TapHound contract: ${loaded.contract.id} is valid (${loaded.contractSha256.slice(0, 12)}...)`);
+            }
+            dependencies.setExitCode(0);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONTRACT_INVALID", error instanceof Error ? error.message : String(error));
+        }
+    });
+    command.addCommand(createContractReviewCommand(dependencies));
+    return command;
+}
+function createContractReviewCommand(dependencies) {
+    const command = new Command("review")
+        .description("Merge reviewer findings into a Verdict (never overwrites fail/invalid)")
+        .requiredOption("--verdict <path>", "Verdict JSON path (verdict.json)")
+        .requiredOption("--findings <path>", "Reviewer findings JSON path")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        // `--project` and `--json` are also declared on the parent command;
+        // commander routes them to the parent when both are declared, so fall
+        // back to the parent's values.
+        const parentOpts = command.parent?.opts() ?? {};
+        const project = parentOpts.project
+            ?? dependencies.cwd();
+        const json = options.json === true
+            || parentOpts.json === true;
+        if (dependencies.contractReview === undefined) {
+            writeFailure(dependencies, json, "CONFIG_INVALID", "TapHound contract review is not configured");
+            return;
+        }
+        const verdictPath = resolve(project, options.verdict);
+        const findingsPath = resolve(project, options.findings);
+        try {
+            await prepareWorkspace(dependencies, project);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONFIG_INVALID", error instanceof Error ? error.message : String(error));
+            return;
+        }
+        try {
+            const verdict = ContractVerdictViewSchema.parse(await dependencies.readJson(verdictPath));
+            const review = ContractReviewInputSchema.parse(await dependencies.readJson(findingsPath));
+            const merged = await dependencies.contractReview.merge({
+                view: verdict,
+                review
+            });
+            await dependencies.contractReview.writeVerdict({
+                verdictPath,
+                view: merged.view
+            });
+            if (json) {
+                writeJson(dependencies.stdout, merged.view);
+            }
+            else {
+                writeLine(dependencies.stdout, `TapHound contract review: ${merged.view.verdict.toUpperCase()} (findings applied: ${String(merged.applied)})`);
+            }
+            dependencies.setExitCode(merged.view.verdict === "pass" ? 0 : 1);
+        }
+        catch (error) {
+            writeFailure(dependencies, json, failureCodeFromUnknown(error) ?? "CONTRACT_INVALID", error instanceof Error ? error.message : String(error));
+        }
+    });
+    return command;
+}

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

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

package/dist/cli/commands/diagnose.js

@@ -0,0 +1,84 @@
+import { resolve } from "node:path";
+import { Command, InvalidArgumentError } from "commander";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../../domain/failure.js";
+import { DIAGNOSTICS_EXPORT_DIR } from "../../domain/workspace.js";
+import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+const REVIEW_NOTE = "Review the file before sharing it. It holds command outcomes, "
+    + "timings, and failure codes; project paths, package, Activity and Journey "
+    + "names, locator values, device serials, screenshots, UI hierarchies, and "
+    + "log text are left out or replaced by aliases.";
+function positiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 1000) {
+        throw new InvalidArgumentError("must be an integer from 1 to 1000");
+    }
+    return parsed;
+}
+function exportFileName(at) {
+    return `taphound-diagnostics-${at.toISOString().replaceAll(":", "-")}.json`;
+}
+export function createDiagnoseCommand(dependencies) {
+    return new Command("diagnose")
+        .description("Collect redacted diagnostics to attach to TapHound feedback")
+        .addCommand(new Command("export")
+        .description("Write a redacted diagnostics bundle from the local journal and recent reports")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--out <path>", `Bundle path (default ${DIAGNOSTICS_EXPORT_DIR}/<timestamp>.json)`)
+        .option("--events <count>", "Most recent journal events to include", positiveInteger, 50)
+        .option("--runs <count>", "Most recent referenced runs to summarize", positiveInteger, 10)
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        const json = options.json === true;
+        const diagnostics = dependencies.diagnosticsExport;
+        if (diagnostics === undefined) {
+            const output = failureOutput(2, "CONFIG_INVALID", "TapHound diagnostics export is not configured");
+            if (json) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(2);
+            return;
+        }
+        try {
+            const projectRoot = resolve(dependencies.cwd(), options.project);
+            const bundle = await diagnostics.export({
+                projectRoot,
+                eventLimit: options.events,
+                runLimit: options.runs
+            });
+            const path = options.out === undefined
+                ? resolve(projectRoot, DIAGNOSTICS_EXPORT_DIR, exportFileName(new Date(bundle.generatedAt)))
+                : resolve(dependencies.cwd(), options.out);
+            await diagnostics.write(path, `${JSON.stringify(bundle, null, 2)}\n`);
+            if (json) {
+                writeJson(dependencies.stdout, {
+                    status: "exported",
+                    exitCode: 0,
+                    path,
+                    events: bundle.journal.events.length,
+                    runs: bundle.runs.length
+                });
+            }
+            else {
+                writeLine(dependencies.stdout, `TapHound diagnostics: ${path}\n${String(bundle.journal.events.length)} event(s), `
+                    + `${String(bundle.runs.length)} run summary(ies)`);
+            }
+            writeLine(dependencies.stderr, REVIEW_NOTE);
+            dependencies.setExitCode(0);
+        }
+        catch (error) {
+            const code = failureCodeFromUnknown(error) ?? "INTERNAL_ERROR";
+            const exitCode = exitCodeForFailure(code);
+            const output = failureOutput(exitCode, code, errorMessage(error));
+            if (json) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(exitCode);
+        }
+    }));
+}

package/dist/cli/commands/doctor.js

@@ -1,10 +1,12 @@
 import { resolve } from "node:path";
 import { Command } from "commander";
 import { TapHoundConfigSchema } from "../../domain/config.js";
+import { CONFIG_PATH } from "../../domain/workspace.js";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../../domain/failure.js";
 import { doctorMessage, errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
-async function configuredPackageName(dependencies, options) {
+async function configuredConfig(dependencies, options) {
     try {
-        return TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config))).run.packageName;
+        return TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
     }
     catch {
         return undefined;
@@ -14,14 +16,18 @@ export function createDoctorCommand(dependencies) {
     return new Command("doctor")
         .description("Check TapHound tools, permissions, application, and device")
         .option("--project <path>", "Android project root", dependencies.cwd())
-        .option("--config <path>", "TapHound config path", "taphound.config.json")
+        .option("--config <path>", "TapHound config path", CONFIG_PATH)
         .option("--device <serial>", "Select an online Android device")
         .option("--json", "Emit machine-readable JSON")
         .action(async (options) => {
+        const json = options.json === true;
         try {
-            const packageName = await configuredPackageName(dependencies, options);
+            const config = await configuredConfig(dependencies, options);
             const report = await dependencies.doctor.run({
-                ...(packageName === undefined ? {} : { packageName }),
+                ...(config === undefined ? {} : { packageName: config.run.packageName }),
+                ...(config?.ui?.backend === undefined
+                    ? {}
+                    : { requestedUiBackend: config.ui.backend }),
                 ...(options.device === undefined
                     ? {}
                     : { requestedDevice: options.device }),
@@ -29,7 +35,7 @@ export function createDoctorCommand(dependencies) {
                     ? {}
                     : { signal: dependencies.signal })
             });
-            if (options.json === true) {
+            if (json) {
                 writeJson(dependencies.stdout, report);
             }
             else {
@@ -38,14 +44,15 @@ export function createDoctorCommand(dependencies) {
             dependencies.setExitCode(report.status === "passed" ? 0 : 3);
         }
         catch (error) {
-            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
-            if (options.json === true) {
+            const code = failureCodeFromUnknown(error) ?? "INTERNAL_ERROR";
+            const output = failureOutput(exitCodeForFailure(code), code, errorMessage(error));
+            if (json) {
                 writeJson(dependencies.stdout, output);
             }
             else {
                 writeLine(dependencies.stderr, output.failure.message);
             }
-            dependencies.setExitCode(4);
+            dependencies.setExitCode(exitCodeForFailure(code));
         }
     });
 }