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

package/dist/cli/commands/record.js

@@ -1,20 +1,28 @@
 import { resolve } from "node:path";
 import { Command } from "commander";
 import { TapHoundConfigSchema } from "../../domain/config.js";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../../domain/failure.js";
+import { assertArtifactDirectory, CONFIG_PATH } from "../../domain/workspace.js";
+import { ResolvedJourneyPathSchema } from "../../domain/journey-composition.js";
 import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+import { prepareWorkspace } from "../workspace-guard.js";
 export function createRecordCommand(dependencies) {
     return new Command("record")
         .description("Interactively record a TapHound Journey")
         .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")
         .requiredOption("--name <name>", "Journey name")
-        .requiredOption("--output <path>", "Journey output path")
+        .requiredOption("--output <path>", "Journey output under .taphound/journeys")
         .option("--json", "Emit machine-readable JSON")
         .action(async (options) => {
         let config;
+        let outputPath;
         try {
             config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
+            assertArtifactDirectory(options.project, config.artifactsDir);
+            outputPath = resolve(options.project, ResolvedJourneyPathSchema.parse(options.output));
+            await prepareWorkspace(dependencies, options.project);
         }
         catch (error) {
             const output = failureOutput(2, "CONFIG_INVALID", errorMessage(error));
@@ -30,6 +38,9 @@ export function createRecordCommand(dependencies) {
         try {
             const doctor = await dependencies.doctor.run({
                 packageName: config.run.packageName,
+                ...(config.ui?.backend === undefined
+                    ? {}
+                    : { requestedUiBackend: config.ui.backend }),
                 ...(options.device === undefined
                     ? {}
                     : { requestedDevice: options.device }),
@@ -58,7 +69,7 @@ export function createRecordCommand(dependencies) {
                 projectRoot: options.project,
                 deviceSerial,
                 journeyName: options.name,
-                outputPath: resolve(options.project, options.output),
+                outputPath,
                 ...(dependencies.signal === undefined
                     ? {}
                     : { signal: dependencies.signal })
@@ -75,14 +86,16 @@ export function createRecordCommand(dependencies) {
             dependencies.setExitCode(result.status === "failed" ? 1 : 0);
         }
         catch (error) {
-            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+            const code = failureCodeFromUnknown(error) ?? "INTERNAL_ERROR";
+            const exitCode = exitCodeForFailure(code);
+            const output = failureOutput(exitCode, code, errorMessage(error));
             if (options.json === true) {
                 writeJson(dependencies.stdout, output);
             }
             else {
                 writeLine(dependencies.stderr, output.failure.message);
             }
-            dependencies.setExitCode(4);
+            dependencies.setExitCode(exitCode);
         }
     });
 }

package/dist/cli/commands/verify.js

@@ -1,106 +1,316 @@
 import { resolve } from "node:path";
 import { Command } from "commander";
+import { readCliVersion } from "../version.js";
+import { runDiffVerification } from "../diff-verification.js";
+import { loadPublishedReplayPolicy } from "../../application/generation/replay-policy-loader.js";
 import { TapHoundConfigSchema } from "../../domain/config.js";
-import { JourneySchema } from "../../domain/journey.js";
+import { DEFAULT_DEVICE_ROLE, JourneySchema } from "../../domain/journey.js";
+import { assertArtifactDirectory, CONFIG_PATH } from "../../domain/workspace.js";
+import { exitCodeForFailure } from "../../domain/failure.js";
 import { errorMessage, failureOutput, writeJson, writeLine } from "../output.js";
+import { prepareWorkspace } from "../workspace-guard.js";
 function toolVersions(checks) {
     return Object.fromEntries(checks.flatMap((check) => (check.version === undefined
         || !["node", "adb", "android"].includes(check.name)
         ? []
         : [[check.name, check.version]])));
 }
-export function createVerifyCommand(dependencies) {
-    return new Command("verify")
-        .description("Deterministically verify a TapHound Journey")
-        .option("--project <path>", "Android project root", dependencies.cwd())
-        .option("--config <path>", "TapHound config path", "taphound.config.json")
-        .requiredOption("--journey <path>", "TapHound Journey path")
-        .option("--device <serial>", "Select an online Android device")
-        .option("--package <name>", "Override run.packageName")
-        .option("--activity <name>", "Override run.activity")
-        .option("--reports <path>", "Override report output directory")
-        .option("--json", "Emit one machine-readable JSON value")
-        .action(async (options) => {
-        let config;
-        let journey;
+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);
+}
+async function runDoctorAndVerify(dependencies, options, config, journey, projectRoot) {
+    const json = options.json === true;
+    let replayPolicy;
+    if (options.policyFromMeta === true) {
         try {
-            const rawConfig = await dependencies.readJson(resolve(options.project, options.config));
-            const parsed = TapHoundConfigSchema.parse(rawConfig);
-            config = TapHoundConfigSchema.parse({
-                ...parsed,
-                run: {
-                    packageName: options.package ?? parsed.run.packageName,
-                    activity: options.activity ?? parsed.run.activity
-                },
-                artifactsDir: options.reports ?? parsed.artifactsDir
+            const journeyPath = resolve(projectRoot, options.journey);
+            replayPolicy = await loadPublishedReplayPolicy({
+                readJson: dependencies.readJson,
+                projectRoot,
+                journeyPath,
+                journey
             });
-            journey = JourneySchema.parse(await dependencies.readJson(resolve(options.project, options.journey)));
         }
         catch (error) {
-            const output = failureOutput(2, "CONFIG_INVALID", errorMessage(error));
-            if (options.json === true) {
+            writeFailure(dependencies, json, "REPLAY_POLICY_UNAVAILABLE", errorMessage(error));
+            return;
+        }
+    }
+    try {
+        const doctor = await dependencies.doctor.run({
+            packageName: config.run.packageName,
+            ...(config.ui?.backend === undefined
+                ? {}
+                : { requestedUiBackend: config.ui.backend }),
+            ...(options.device === undefined
+                ? {}
+                : { requestedDevice: options.device }),
+            ...(dependencies.signal === undefined
+                ? {}
+                : { signal: dependencies.signal })
+        });
+        if (doctor.status === "failed") {
+            const output = failureOutput(3, doctor.failureCode ?? "ENVIRONMENT_MISSING_TOOL", doctor.checks.find((check) => check.status === "failed")?.message
+                ?? "TapHound environment preflight failed");
+            if (json) {
                 writeJson(dependencies.stdout, output);
             }
             else {
                 writeLine(dependencies.stderr, output.failure.message);
             }
-            dependencies.setExitCode(2);
+            dependencies.setExitCode(3);
             return;
         }
+        const deviceSerial = options.device ?? doctor.deviceSerial;
+        if (deviceSerial === undefined) {
+            throw new Error("Doctor did not select a device");
+        }
+        if (journey.devices.length > 1) {
+            const output = failureOutput(3, "DEVICE_ROLE_UNMAPPED", `Journey declares multiple devices; map each role with --device <role>=<serial> for: ${journey.devices.map((device) => device.role).join(", ")}`);
+            if (json) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(3);
+            return;
+        }
+        writeLine(dependencies.stderr, `TapHound: verifying ${journey.name}`);
+        const result = await dependencies.verifier.verify({
+            config: replayPolicy === undefined ? config : { ...config, idle: replayPolicy.idle },
+            journey,
+            projectRoot,
+            devices: [{
+                    role: journey.devices[0]?.role ?? DEFAULT_DEVICE_ROLE,
+                    deviceSerial
+                }],
+            toolVersions: toolVersions(doctor.checks),
+            manualReplay: process.stdin.isTTY,
+            ...(replayPolicy === undefined ? {} : {
+                generatedReplayPolicy: replayPolicy.generatedReplayPolicy,
+                requireFocusedInput: replayPolicy.requireFocusedInput
+            }),
+            ...(dependencies.signal === undefined
+                ? {}
+                : { signal: dependencies.signal })
+        });
+        if (json) {
+            writeJson(dependencies.stdout, result);
+        }
+        else {
+            writeLine(dependencies.stdout, `TapHound verify: ${result.status.toUpperCase()}\nReport: ${result.reportPath}`);
+        }
+        dependencies.setExitCode(result.exitCode);
+    }
+    catch (error) {
+        const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+        if (json) {
+            writeJson(dependencies.stdout, output);
+        }
+        else {
+            writeLine(dependencies.stderr, output.failure.message);
+        }
+        dependencies.setExitCode(4);
+    }
+}
+async function runContractVerify(dependencies, options, config, projectRoot) {
+    const json = options.json === true;
+    if (dependencies.contractVerifier === undefined) {
+        writeFailure(dependencies, json, "CONFIG_INVALID", "TapHound contract verification is not configured");
+        return;
+    }
+    let replayPolicy;
+    if (options.policyFromMeta === true) {
         try {
-            const doctor = await dependencies.doctor.run({
-                packageName: config.run.packageName,
-                ...(options.device === undefined
-                    ? {}
-                    : { requestedDevice: options.device }),
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
+            if (dependencies.contractLoader === undefined) {
+                throw new Error("Contract loader is not configured");
+            }
+            const loaded = await dependencies.contractLoader.load({
+                projectRoot,
+                contractPath: resolve(projectRoot, options.contract)
+            });
+            replayPolicy = await loadPublishedReplayPolicy({
+                readJson: dependencies.readJson,
+                projectRoot,
+                journeyPath: loaded.journeyPath,
+                journey: loaded.journey
+            });
+        }
+        catch (error) {
+            writeFailure(dependencies, json, "REPLAY_POLICY_UNAVAILABLE", errorMessage(error));
+            return;
+        }
+    }
+    try {
+        const doctor = await dependencies.doctor.run({
+            packageName: config.run.packageName,
+            ...(config.ui?.backend === undefined
+                ? {}
+                : { requestedUiBackend: config.ui.backend }),
+            ...(options.device === undefined
+                ? {}
+                : { requestedDevice: options.device }),
+            ...(dependencies.signal === undefined
+                ? {}
+                : { signal: dependencies.signal })
+        });
+        if (doctor.status === "failed") {
+            writeFailure(dependencies, json, doctor.failureCode ?? "ENVIRONMENT_MISSING_TOOL", doctor.checks.find((check) => check.status === "failed")?.message
+                ?? "TapHound environment preflight failed");
+            return;
+        }
+        const deviceSerial = options.device ?? doctor.deviceSerial;
+        if (deviceSerial === undefined) {
+            throw new Error("Doctor did not select a device");
+        }
+        writeLine(dependencies.stderr, `TapHound: verifying contract ${resolve(projectRoot, options.contract)}`);
+        const result = await dependencies.contractVerifier.verify({
+            projectRoot,
+            config: replayPolicy === undefined ? config : { ...config, idle: replayPolicy.idle },
+            devices: [{
+                    role: DEFAULT_DEVICE_ROLE,
+                    deviceSerial
+                }],
+            toolVersions: toolVersions(doctor.checks),
+            taphoundVersion: readCliVersion(),
+            contractPath: resolve(projectRoot, options.contract),
+            manualReplay: process.stdin.isTTY,
+            ...(replayPolicy === undefined ? {} : {
+                generatedReplayPolicy: replayPolicy.generatedReplayPolicy,
+                requireFocusedInput: replayPolicy.requireFocusedInput
+            }),
+            ...(dependencies.signal === undefined
+                ? {}
+                : { signal: dependencies.signal })
+        });
+        if (json) {
+            writeJson(dependencies.stdout, result.view);
+        }
+        else {
+            writeLine(dependencies.stdout, `TapHound verify --contract: ${result.view.verdict.toUpperCase()}\nReport: ${result.view.reportPath ?? "n/a"}`);
+        }
+        dependencies.setExitCode(result.exitCode);
+    }
+    catch (error) {
+        const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+        if (json) {
+            writeJson(dependencies.stdout, output);
+        }
+        else {
+            writeLine(dependencies.stderr, output.failure.message);
+        }
+        dependencies.setExitCode(4);
+    }
+}
+export function createVerifyCommand(dependencies) {
+    return new Command("verify")
+        .description("Deterministically verify a TapHound Journey or Acceptance Contract")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--config <path>", "TapHound config path", CONFIG_PATH)
+        .option("--journey <path>", "TapHound Journey path")
+        .option("--contract <path>", "Acceptance Contract path (mutually exclusive with --journey)")
+        .option("--diff <ref>", "Verify the Journeys a Git change affects (diff mode)")
+        .option("--base <ref>", "Base Git ref for --diff (default origin/main)")
+        .option("--head <ref>", "Head Git ref for --diff (HEAD by default, or WORKTREE)")
+        .option("--scope <p0,p1,p2>", "Selection tiers for --diff", "p0,p1")
+        .option("--device <serial>", "Select an online Android device")
+        .option("--package <name>", "Override run.packageName")
+        .option("--activity <name>", "Override run.activity")
+        .option("--reports <path>", "Report output under .taphound/build")
+        .option("--policy-from-meta", "Require the bound strict Generation Replay policy")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        if (options.policyFromMeta === true && options.diff !== undefined) {
+            writeFailure(dependencies, options.json === true, "CONFIG_INVALID", "--policy-from-meta supports --journey or --contract, not --diff");
+            return;
+        }
+        if (options.diff !== undefined) {
+            await runDiffVerification(dependencies, {
+                project: options.project,
+                config: options.config,
+                base: options.base ?? options.diff,
+                ...(options.head === undefined ? {} : { head: options.head }),
+                ...(options.device === undefined ? {} : { device: options.device }),
+                ...(options.scope === undefined ? {} : { scope: options.scope }),
+                json: options.json === true
             });
-            if (doctor.status === "failed") {
-                const output = failureOutput(3, doctor.failureCode ?? "ENVIRONMENT_MISSING_TOOL", doctor.checks.find((check) => check.status === "failed")?.message
-                    ?? "TapHound environment preflight failed");
+            return;
+        }
+        if (options.journey === undefined && options.contract === undefined) {
+            writeFailure(dependencies, options.json === true, "CONFIG_INVALID", "verify requires exactly one of --journey or --contract");
+            return;
+        }
+        if (options.journey !== undefined && options.contract !== undefined) {
+            writeFailure(dependencies, options.json === true, "CONFIG_INVALID", "--journey and --contract are mutually exclusive");
+            return;
+        }
+        let config;
+        if (options.contract === undefined) {
+            let journey;
+            try {
+                const rawConfig = await dependencies.readJson(resolve(options.project, options.config));
+                const parsed = TapHoundConfigSchema.parse(rawConfig);
+                config = TapHoundConfigSchema.parse({
+                    ...parsed,
+                    run: {
+                        packageName: options.package ?? parsed.run.packageName,
+                        activity: options.activity ?? parsed.run.activity
+                    },
+                    artifactsDir: options.reports ?? parsed.artifactsDir
+                });
+                assertArtifactDirectory(options.project, config.artifactsDir);
+                await prepareWorkspace(dependencies, options.project);
+                journey = JourneySchema.parse(await dependencies.readJson(resolve(options.project, options.journey)));
+            }
+            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(3);
+                dependencies.setExitCode(2);
                 return;
             }
-            const deviceSerial = options.device ?? doctor.deviceSerial;
-            if (deviceSerial === undefined) {
-                throw new Error("Doctor did not select a device");
-            }
-            writeLine(dependencies.stderr, `TapHound: verifying ${journey.name}`);
-            const result = await dependencies.verifier.verify({
-                config,
-                journey,
-                projectRoot: options.project,
-                deviceSerial,
-                toolVersions: toolVersions(doctor.checks),
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
+            await runDoctorAndVerify(dependencies, options, config, journey, options.project);
+            return;
+        }
+        let contractConfig;
+        try {
+            const rawConfig = await dependencies.readJson(resolve(options.project, options.config));
+            const parsed = TapHoundConfigSchema.parse(rawConfig);
+            contractConfig = TapHoundConfigSchema.parse({
+                ...parsed,
+                run: {
+                    packageName: options.package ?? parsed.run.packageName,
+                    activity: options.activity ?? parsed.run.activity
+                },
+                artifactsDir: options.reports ?? parsed.artifactsDir
             });
-            if (options.json === true) {
-                writeJson(dependencies.stdout, result);
-            }
-            else {
-                writeLine(dependencies.stdout, `TapHound verify: ${result.status.toUpperCase()}\nReport: ${result.reportPath}`);
-            }
-            dependencies.setExitCode(result.exitCode);
+            assertArtifactDirectory(options.project, contractConfig.artifactsDir);
+            await prepareWorkspace(dependencies, options.project);
         }
         catch (error) {
-            const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(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(4);
+            dependencies.setExitCode(2);
+            return;
         }
+        await runContractVerify(dependencies, options, contractConfig, options.project);
     });
 }

package/dist/cli/dependencies.d.ts

@@ -1,19 +1,51 @@
+import type { MobileMcpTools } from "../adapters/runtime/mobile-mcp/mobile-mcp-tools.js";
+import type { Clock } from "../ports/clock.js";
+import { type AlignCameraResult } from "../application/align/align-service.js";
+import { type ObserveInput } from "../application/observe/observe-service.js";
+import type { ObserveReport } from "../domain/observation.js";
+import { ContextGenerator } from "../application/context/context-generator.js";
+import { ContextRehasher } from "../application/context/context-rehasher.js";
 import { ContextValidator } from "../application/context/context-validator.js";
+import { ContextLoader } from "../application/context/context-loader.js";
+import { ContextRefresher } from "../application/context/context-refresher.js";
 import type { DoctorReport, DoctorRunInput } from "../application/doctor/doctor-service.js";
 import { GenerationConfirmationService } from "../application/generation/generation-confirmation-service.js";
 import { GenerationFinalizer } from "../application/generation/generation-finalizer.js";
+import { GenerationRecoveryService } from "../application/generation/generation-recovery-service.js";
+import { GenerationReopenService } from "../application/generation/generation-reopen-service.js";
+import { type GenerationIdlePolicyPatch } from "../application/generation/generation-config-service.js";
+import { type GenerationReplaceResult } from "../application/generation/generation-replace-service.js";
 import { GenerationStarter, type GenerationStartInput } from "../application/generation/generation-starter.js";
+import type { ResolvedProjectContext } from "../domain/project-context.js";
 import { GenerationStepExecutor } from "../application/generation/generation-step-executor.js";
 import { RuntimeObserver, type RuntimeObservation, type RuntimeObserveInput } from "../application/generation/runtime-observer.js";
 import { type InitInput } from "../application/init/init-service.js";
+import { JourneyResolver } from "../application/journey/journey-resolver.js";
+import { ExternalFlowResolver } from "../application/journey/external-flow-resolver.js";
 import { ProjectDescriber } from "../application/project/project-describer.js";
 import { type RecordInput, type RecordResult } from "../application/recorder/recorder-service.js";
+import { type ContractVerifyInput, type ContractVerifyResult } from "../application/contract/contract-verifier.js";
+import { ContractLoader } from "../application/contract/contract-loader.js";
+import { ContractReviewMerger } from "../application/contract/contract-review.js";
+import { BaselineService } from "../application/checkpoint/baseline-service.js";
+import type { ContractVerdictView } from "../domain/contract.js";
+import type { FailureClassification } from "../domain/failure-classification.js";
 import { type VerifyInput, type VerifyResult } from "../application/runtime/verify-runtime.js";
 import type { TapHoundConfig } from "../domain/config.js";
+import { type RuntimeBackendChoice } from "../domain/runtime.js";
+import type { GitDiffPort } from "../ports/git-diff.js";
+import type { ImpactSet, ChangeSet } from "../domain/impact.js";
+import { type RuntimeBackend } from "../ports/runtime-backend.js";
+import type { UiBackendSelection } from "../domain/ui-backend.js";
 import type { InitResult } from "../domain/init.js";
-import type { GenerationSession } from "../domain/generation.js";
+import { type GenerationSession } from "../domain/generation.js";
 import type { InitPromptPort } from "../ports/init-prompt.js";
+import type { RecorderPromptPort } from "../ports/recorder-prompt.js";
 import type { GenerationSessionStore } from "../ports/generation-session-store.js";
+import type { DetachedProcessLauncher } from "../ports/detached-process-launcher.js";
+import type { WorkspaceLayoutPort } from "../ports/workspace-layout.js";
+import type { JourneyCompositionStore } from "../ports/journey-composition-store.js";
+import type { KnowledgeRehashResult, LoadedKnowledgeBundle } from "../ports/knowledge-registry.js";
 export interface TextOutput {
     write: (content: string) => void;
 }
@@ -22,8 +54,23 @@ export interface GenerationCliRuntime {
     executor: Pick<GenerationStepExecutor, "execute">;
     observer: Pick<RuntimeObserver, "observe">;
     finalizer: Pick<GenerationFinalizer, "finalize">;
+    recovery: Pick<GenerationRecoveryService, "status" | "retry">;
+    reopen: Pick<GenerationReopenService, "reopen">;
+    archive: (id: string) => Promise<GenerationSession>;
+    list: () => Promise<readonly GenerationSession[]>;
     readSession: (id: string) => Promise<GenerationSession>;
+    readContextSnapshot: (id: string) => Promise<ResolvedProjectContext>;
     assertConfigIdentity: (id: string) => Promise<void>;
+    updateIdlePolicy: (id: string, patch: GenerationIdlePolicyPatch) => Promise<GenerationSession>;
+    replace: (input: {
+        generationId: string;
+        stepIndex: number;
+        projectRoot: string;
+        config: TapHoundConfig;
+        toolVersions: Record<string, string>;
+        manualReplay?: boolean | undefined;
+        signal?: AbortSignal | undefined;
+    }) => Promise<GenerationReplaceResult>;
 }
 export interface CliDependencies {
     signal?: AbortSignal | undefined;
@@ -36,8 +83,30 @@ export interface CliDependencies {
     verifier: {
         verify: (input: VerifyInput) => Promise<VerifyResult>;
     };
+    contractVerifier?: {
+        verify: (input: ContractVerifyInput) => Promise<ContractVerifyResult>;
+    } | undefined;
+    contractLoader?: Pick<ContractLoader, "load"> | undefined;
+    baselineService?: Pick<BaselineService, "captureFromReport" | "write" | "compare"> | undefined;
+    failureClassifier?: {
+        classify: (reportPath: string) => Promise<FailureClassification>;
+    } | undefined;
+    contractReview?: {
+        merge: ContractReviewMerger["merge"];
+        writeVerdict: (input: {
+            verdictPath: string;
+            view: ContractVerdictView;
+        }) => Promise<void>;
+    } | undefined;
     projectDescriber: Pick<ProjectDescriber, "describe">;
     contextValidator: Pick<ContextValidator, "validate">;
+    contextLoader: Pick<ContextLoader, "load" | "readIndex">;
+    contextRefresher: Pick<ContextRefresher, "refresh">;
+    contextGenerator: Pick<ContextGenerator, "generate">;
+    contextRehasher: Pick<ContextRehasher, "rehash">;
+    journeyResolver?: Pick<JourneyResolver, "resolve" | "resolveFlow" | "listFlows"> | undefined;
+    journeyCompositionStore?: Pick<JourneyCompositionStore, "writeText" | "read" | "listJourneyPaths" | "readJourneyMeta"> | undefined;
+    externalFlowResolver?: Pick<ExternalFlowResolver, "resolve" | "list"> | undefined;
     generationStarter: {
         start: (input: GenerationStartInput) => Promise<Awaited<ReturnType<GenerationStarter["start"]>>>;
     };
@@ -50,17 +119,72 @@ export interface CliDependencies {
         projectRoot: string;
         config: TapHoundConfig;
     }) => GenerationCliRuntime;
+    detachedProcess?: DetachedProcessLauncher | undefined;
+    cliEntryPath?: string | undefined;
+    createDetachedJobId?: (() => string) | undefined;
     init: {
         install: (input: InitInput) => Promise<InitResult>;
     };
     initPrompt: Pick<InitPromptPort, "selectAgents">;
+    align: {
+        alignCamera: (input: {
+            projectRoot: string;
+            deviceSerial?: string | undefined;
+            force?: boolean | undefined;
+            json: boolean;
+            signal?: AbortSignal | undefined;
+        }) => Promise<AlignCameraResult>;
+    };
+    observer: (layoutTimeoutMs: number, backend?: UiBackendSelection, cacheEnabled?: boolean) => {
+        observe: (input: ObserveInput) => Promise<ObserveReport>;
+    };
+    workspaceLayout: WorkspaceLayoutPort;
+    impact?: {
+        resolve: (input: {
+            projectRoot: string;
+            packageName: string;
+            changeSet: ChangeSet;
+        }) => Promise<ImpactSet>;
+    } | undefined;
+    gitDiff?: GitDiffPort | undefined;
+    knowledge?: {
+        load: (input: {
+            projectRoot: string;
+            packageName?: string | undefined;
+            expectedKnowledgeHash?: string | undefined;
+        }) => Promise<LoadedKnowledgeBundle>;
+        rehash: (input: {
+            projectRoot: string;
+            packageName: string;
+        }) => Promise<KnowledgeRehashResult>;
+    } | undefined;
     readJson: (path: string) => Promise<unknown>;
+    readFile: (path: string) => Promise<Buffer>;
     cwd: () => string;
     stdout: TextOutput;
     stderr: TextOutput;
     setExitCode: (code: number) => void;
+    close?: (() => Promise<void>) | undefined;
 }
 export interface ProductionDependencyOptions {
     generationStoreFactory?: (projectRoot: string) => GenerationSessionStore;
+    runtimeBackendChoice?: RuntimeBackendChoice | undefined;
+    mobileMcpToolsFactory?: (() => MobileMcpTools) | undefined;
+    /**
+     * Replaces the device backend while keeping every other production wire.
+     * Used by the simulated-device parity harness; the CLI never sets it.
+     */
+    runtimeBackend?: RuntimeBackend | undefined;
+    /** Single time source for waits, polling, and cache TTLs (tests inject a virtual clock). */
+    clock?: Clock | undefined;
+    /** Replaces the interactive Recorder prompt (the parity harness scripts it). */
+    recorderPrompt?: RecorderPromptPort | undefined;
 }
+export declare function loadKnowledgeResilient(load: (input: {
+    projectRoot: string;
+    packageName: string;
+}) => Promise<LoadedKnowledgeBundle>, input: {
+    projectRoot: string;
+    packageName: string;
+}): Promise<LoadedKnowledgeBundle>;
 export declare function createProductionDependencies(signal?: AbortSignal, options?: ProductionDependencyOptions): CliDependencies;