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

package/dist/cli/commands/generation.js

@@ -1,511 +1,7 @@
-import { resolve } from "node:path";
 import { Command } from "commander";
-import { z } from "zod";
-import { GenerationFinalizationError, GenerationOutputPathSchema } from "../../application/generation/generation-finalizer.js";
-import { GenerationOperationError } from "../../application/generation/generation-starter.js";
-import { TapHoundConfigSchema } from "../../domain/config.js";
-import { GenerationSessionIdSchema } from "../../domain/generation.js";
-import { ProjectContextSchema } from "../../domain/project-context.js";
-import { ProposedStepSchema } from "../../domain/proposed-step.js";
-import { RuntimeSnapshotSchema } from "../../domain/runtime-snapshot.js";
-import { GenerationSessionStoreError } from "../../ports/generation-session-store.js";
-import { GenerationPromptCancelledError } from "../../ports/generation-prompt.js";
-import { errorMessage, writeJson, writeLine } from "../output.js";
-const PlannerEnvelopeSchema = z.strictObject({
-    version: z.literal(1),
-    proposal: ProposedStepSchema,
-    snapshot: RuntimeSnapshotSchema
-});
-const ManualActionSchema = z.enum([
-    "click",
-    "longClick",
-    "inputText",
-    "swipe",
-    "scrollTo",
-    "back",
-    "wait"
-]);
-function writeFailure(dependencies, options, exitCode, code, error) {
-    const output = {
-        status: "error",
-        exitCode,
-        failure: {
-            code,
-            message: errorMessage(error)
-        }
-    };
-    if (options.json === true) {
-        writeJson(dependencies.stdout, output);
-    }
-    else {
-        writeLine(dependencies.stderr, output.failure.message);
-    }
-    dependencies.setExitCode(exitCode);
-}
-async function loadConfig(dependencies, options) {
-    try {
-        return TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
-    }
-    catch (error) {
-        throw new GenerationOperationError("CONFIG_INVALID", errorMessage(error));
-    }
-}
-function tools(checks) {
-    return Object.fromEntries(checks.flatMap((check) => (check.status === "passed" && check.version !== undefined
-        ? [[check.name, check.version]]
-        : [])));
-}
-function writeSuccess(dependencies, options, output, message) {
-    if (options.json === true) {
-        writeJson(dependencies.stdout, output);
-    }
-    else {
-        writeLine(dependencies.stdout, message);
-    }
-    dependencies.setExitCode(0);
-}
-function mappedFailure(dependencies, options, error) {
-    if (error instanceof z.ZodError || error instanceof SyntaxError) {
-        writeFailure(dependencies, options, 2, "CONTEXT_INVALID", error);
-        return;
-    }
-    if (dependencies.signal?.aborted === true) {
-        writeFailure(dependencies, options, 1, "RECOVERY_REQUIRED", "Generation command was cancelled");
-        return;
-    }
-    if (error instanceof GenerationFinalizationError) {
-        writeFailure(dependencies, options, 1, error.code, error);
-        return;
-    }
-    if (error instanceof GenerationOperationError) {
-        const exitCode = error.code === "CONFIG_INVALID"
-            || error.code === "CONTEXT_INVALID"
-            ? 2
-            : 1;
-        writeFailure(dependencies, options, exitCode, error.code, error);
-        return;
-    }
-    if (error instanceof GenerationSessionStoreError) {
-        const exitCode = error.code === "INVALID_ID"
-            || error.code === "INVALID_SESSION"
-            || error.code === "INVALID_REVISION"
-            ? 2
-            : error.code === "IO_ERROR" || error.code === "LOCK_TIMEOUT"
-                ? 4
-                : 1;
-        writeFailure(dependencies, options, exitCode, error.code, error);
-        return;
-    }
-    if (error instanceof GenerationPromptCancelledError) {
-        writeFailure(dependencies, options, 1, "RECOVERY_REQUIRED", error);
-        return;
-    }
-    if (error instanceof Error
-        && error.message.includes("requires local TTY")) {
-        writeFailure(dependencies, options, 1, "RISK_CONFIRMATION_REQUIRED", error);
-        return;
-    }
-    writeFailure(dependencies, options, 4, "INTERNAL_ERROR", error);
-}
-async function executeApproved(dependencies, options, runtime, input) {
-    const result = await runtime.executor.execute({
-        ...input,
-        ...(dependencies.signal === undefined
-            ? {}
-            : { signal: dependencies.signal })
-    });
-    if (result.status !== "succeeded") {
-        writeFailure(dependencies, options, 1, result.failure.code, result.failure.message);
-        return;
-    }
-    const session = await runtime.readSession(input.generationId);
-    writeSuccess(dependencies, options, {
-        status: "succeeded",
-        exitCode: 0,
-        generationId: input.generationId,
-        revision: session.revision,
-        stepIndex: session.candidateSteps.length - 1,
-        step: result.step,
-        source: input.source
-    }, `Generation step ${String(session.candidateSteps.length - 1)} succeeded`);
-}
-function requireRuntime(dependencies, projectRoot, config) {
-    if (dependencies.generationRuntime === undefined) {
-        throw new Error("Generation command runtime is unavailable");
-    }
-    return dependencies.generationRuntime({ projectRoot, config });
-}
-async function assertRuntimeConfig(runtime, generationId) {
-    await runtime.assertConfigIdentity(generationId);
-}
-function createStartCommand(dependencies) {
-    return new Command("start")
-        .description("Start a Core-owned generation session")
-        .option("--project <path>", "Android project root", dependencies.cwd())
-        .option("--config <path>", "TapHound config path", "taphound.config.json")
-        .requiredOption("--context <path>", "Project Context path")
-        .option("--device <serial>", "Select an online Android device")
-        .option("--json", "Emit one machine-readable JSON value")
-        .action(async (options) => {
-        let config;
-        try {
-            config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
-        }
-        catch (error) {
-            writeFailure(dependencies, options, 2, "CONFIG_INVALID", error);
-            return;
-        }
-        let context;
-        try {
-            context = ProjectContextSchema.parse(await dependencies.readJson(resolve(options.project, options.context)));
-        }
-        catch (error) {
-            writeFailure(dependencies, options, 2, "CONTEXT_INVALID", error);
-            return;
-        }
-        try {
-            const doctor = await dependencies.doctor.run({
-                packageName: config.run.packageName,
-                ...(options.device === undefined
-                    ? {}
-                    : { requestedDevice: options.device }),
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            if (doctor.status === "failed") {
-                writeFailure(dependencies, options, 3, 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");
-            }
-            const project = await dependencies.projectDescriber.describe({
-                projectRoot: options.project,
-                config,
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            const session = await dependencies.generationStarter.start({
-                projectRoot: options.project,
-                config,
-                context,
-                project,
-                deviceSerial
-            });
-            const output = {
-                status: "started",
-                exitCode: 0,
-                generationId: session.id,
-                revision: session.revision,
-                bindings: session.bindings,
-                variables: session.variables,
-                target: session.target
-            };
-            if (options.json === true) {
-                writeJson(dependencies.stdout, output);
-            }
-            else {
-                writeLine(dependencies.stdout, `Generation started: ${session.id}`);
-            }
-            dependencies.setExitCode(0);
-        }
-        catch (error) {
-            if (error instanceof GenerationOperationError) {
-                const exitCode = error.code === "CONTEXT_STALE" ? 1 : 2;
-                writeFailure(dependencies, options, exitCode, error.code, error);
-                return;
-            }
-            mappedFailure(dependencies, options, error);
-        }
-    });
-}
-function createObserveCommand(dependencies) {
-    return new Command("observe")
-        .description("Observe and bind authoritative runtime state")
-        .option("--project <path>", "Android project root", dependencies.cwd())
-        .option("--config <path>", "TapHound config path", "taphound.config.json")
-        .requiredOption("--session <id>", "Generation session id")
-        .option("--json", "Emit one machine-readable JSON value")
-        .action(async (options) => {
-        try {
-            const generationId = GenerationSessionIdSchema.parse(options.session);
-            const config = await loadConfig(dependencies, options);
-            const observation = dependencies.generationRuntime === undefined
-                ? await dependencies.runtimeObserver.observe({
-                    projectRoot: options.project,
-                    generationId,
-                    ...(dependencies.signal === undefined
-                        ? {}
-                        : { signal: dependencies.signal })
-                })
-                : await (async () => {
-                    const runtime = requireRuntime(dependencies, options.project, config);
-                    await assertRuntimeConfig(runtime, generationId);
-                    return runtime.observer.observe({
-                        generationId,
-                        ...(dependencies.signal === undefined
-                            ? {}
-                            : { signal: dependencies.signal })
-                    });
-                })();
-            const output = {
-                status: "observed",
-                exitCode: 0,
-                ...observation.binding,
-                snapshot: observation.snapshot
-            };
-            if (options.json === true) {
-                writeJson(dependencies.stdout, output);
-            }
-            else {
-                writeLine(dependencies.stdout, `Generation observed at revision ${String(observation.binding.baseRevision)}`);
-            }
-            dependencies.setExitCode(0);
-        }
-        catch (error) {
-            if (error instanceof GenerationOperationError) {
-                mappedFailure(dependencies, options, error);
-                return;
-            }
-            if (error instanceof GenerationSessionStoreError
-                && (error.code === "REVISION_CONFLICT"
-                    || error.code === "INVALID_TRANSITION")) {
-                writeFailure(dependencies, options, 1, "SNAPSHOT_STALE", error);
-                return;
-            }
-            mappedFailure(dependencies, options, error);
-        }
-    });
-}
-function addCommonOptions(command, dependencies) {
-    return command
-        .option("--project <path>", "Android project root", dependencies.cwd())
-        .option("--config <path>", "TapHound config path", "taphound.config.json")
-        .requiredOption("--session <id>", "Generation session id")
-        .option("--json", "Emit one machine-readable JSON value");
-}
-function createStepCommand(dependencies) {
-    return addCommonOptions(new Command("step")
-        .description("Accept and execute one strict planner proposal")
-        .requiredOption("--input <path>", "Strict proposal envelope path"), dependencies).action(async (options) => {
-        try {
-            const generationId = GenerationSessionIdSchema.parse(options.session);
-            const config = await loadConfig(dependencies, options);
-            const runtime = requireRuntime(dependencies, options.project, config);
-            await assertRuntimeConfig(runtime, generationId);
-            let envelope;
-            try {
-                envelope = PlannerEnvelopeSchema.parse(await dependencies.readJson(resolve(options.project, options.input)));
-            }
-            catch (error) {
-                throw new GenerationOperationError("CONTEXT_INVALID", errorMessage(error));
-            }
-            const confirmation = await runtime.confirmation.request({
-                generationId,
-                proposal: envelope.proposal,
-                snapshot: envelope.snapshot,
-                source: "planner"
-            });
-            if (confirmation.status === "confirmationRequired") {
-                const session = await runtime.readSession(generationId);
-                writeSuccess(dependencies, options, {
-                    status: "confirmationRequired",
-                    exitCode: 0,
-                    generationId,
-                    revision: session.revision,
-                    challenge: confirmation.challenge
-                }, `Confirmation required: ${confirmation.challenge.challengeId}`);
-                return;
-            }
-            await executeApproved(dependencies, options, runtime, {
-                generationId,
-                proposal: confirmation.proposal,
-                snapshot: envelope.snapshot,
-                source: "planner"
-            });
-        }
-        catch (error) {
-            mappedFailure(dependencies, options, error);
-        }
-    });
-}
-function createConfirmCommand(dependencies) {
-    return addCommonOptions(new Command("confirm")
-        .description("Approve and execute Core-owned challenge evidence")
-        .requiredOption("--challenge <id>", "Core confirmation challenge id"), dependencies).action(async (options) => {
-        try {
-            const generationId = GenerationSessionIdSchema.parse(options.session);
-            const challengeId = GenerationSessionIdSchema.parse(options.challenge);
-            const config = await loadConfig(dependencies, options);
-            const runtime = requireRuntime(dependencies, options.project, config);
-            await assertRuntimeConfig(runtime, generationId);
-            const approved = await runtime.confirmation.confirmStored({
-                generationId,
-                challengeId,
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            await executeApproved(dependencies, options, runtime, {
-                generationId,
-                proposal: approved.proposal,
-                snapshot: approved.snapshot,
-                source: approved.source
-            });
-        }
-        catch (error) {
-            mappedFailure(dependencies, options, error);
-        }
-    });
-}
-function createManualCommand(dependencies) {
-    return addCommonOptions(new Command("manual")
-        .description("Build one local TTY manual override proposal")
-        .requiredOption("--action <action>", "Exact ProposedStep action"), dependencies).action(async (options) => {
-        try {
-            const generationId = GenerationSessionIdSchema.parse(options.session);
-            const action = ManualActionSchema.parse(options.action);
-            const config = await loadConfig(dependencies, options);
-            const runtime = requireRuntime(dependencies, options.project, config);
-            await assertRuntimeConfig(runtime, generationId);
-            const existing = await runtime.confirmation.findPendingManual({
-                generationId,
-                action
-            });
-            if (existing !== null) {
-                const session = await runtime.readSession(generationId);
-                writeSuccess(dependencies, options, {
-                    status: "confirmationRequired",
-                    exitCode: 0,
-                    generationId,
-                    revision: session.revision,
-                    challenge: existing.challenge
-                }, `Confirmation required: ${existing.challenge.challengeId}`);
-                return;
-            }
-            const observation = await runtime.observer.observe({
-                generationId,
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            const confirmation = await runtime.confirmation.requestManual({
-                generationId,
-                snapshot: observation.snapshot,
-                manual: {
-                    action,
-                    binding: observation.binding,
-                    before: observation.snapshot.activity,
-                    layout: observation.snapshot.layout
-                },
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            if (confirmation.status === "confirmationRequired") {
-                const session = await runtime.readSession(generationId);
-                writeSuccess(dependencies, options, {
-                    status: "confirmationRequired",
-                    exitCode: 0,
-                    generationId,
-                    revision: session.revision,
-                    challenge: confirmation.challenge
-                }, `Confirmation required: ${confirmation.challenge.challengeId}`);
-                return;
-            }
-            await executeApproved(dependencies, options, runtime, {
-                generationId,
-                proposal: confirmation.proposal,
-                snapshot: observation.snapshot,
-                source: "manualOverride"
-            });
-        }
-        catch (error) {
-            mappedFailure(dependencies, options, error);
-        }
-    });
-}
-function createFinalizeCommand(dependencies) {
-    return addCommonOptions(new Command("finalize")
-        .description("Verify and publish a generated Journey")
-        .requiredOption("--context <path>", "Project Context path")
-        .requiredOption("--output <path>", "Project-relative Journey output")
-        .option("--name <name>", "Generated Journey name")
-        .option("--device <serial>", "Select an online Android device"), dependencies).action(async (options) => {
-        try {
-            const generationId = GenerationSessionIdSchema.parse(options.session);
-            const config = await loadConfig(dependencies, options);
-            let context;
-            try {
-                context = ProjectContextSchema.parse(await dependencies.readJson(resolve(options.project, options.context)));
-            }
-            catch (error) {
-                throw new GenerationOperationError("CONTEXT_INVALID", errorMessage(error));
-            }
-            const outputPath = GenerationOutputPathSchema.parse(options.output);
-            const name = options.name === undefined
-                ? undefined
-                : z.string().trim().min(1).parse(options.name);
-            const doctor = await dependencies.doctor.run({
-                packageName: config.run.packageName,
-                ...(options.device === undefined
-                    ? {}
-                    : { requestedDevice: options.device }),
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            if (doctor.status === "failed") {
-                writeFailure(dependencies, options, 3, 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) {
-                writeFailure(dependencies, options, 3, "DEVICE_UNAVAILABLE", "Doctor did not select a device");
-                return;
-            }
-            const project = await dependencies.projectDescriber.describe({
-                projectRoot: options.project,
-                config,
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            const runtime = requireRuntime(dependencies, options.project, config);
-            const result = await runtime.finalizer.finalize({
-                generationId,
-                projectRoot: options.project,
-                config,
-                context,
-                project,
-                outputPath,
-                ...(name === undefined ? {} : { name }),
-                deviceSerial,
-                toolVersions: tools(doctor.checks),
-                ...(dependencies.signal === undefined
-                    ? {}
-                    : { signal: dependencies.signal })
-            });
-            writeSuccess(dependencies, options, {
-                status: "verified",
-                exitCode: 0,
-                generationId,
-                bundlePath: result.bundlePath,
-                journeyPath: result.journeyPath,
-                metaPath: result.metaPath,
-                replayed: result.replayed
-            }, `Generation verified: ${result.journeyPath}`);
-        }
-        catch (error) {
-            mappedFailure(dependencies, options, error);
-        }
-    });
-}
+import { createFinalizeCommand, createRecoverCommand, createReopenCommand } from "./generation/lifecycle-commands.js";
+import { createArchiveCommand, createConfigCommand, createListCommand, createObserveCommand, createStartCommand, createStatusCommand } from "./generation/session-commands.js";
+import { createBridgeCommand, createConfirmCommand, createManualCommand, createStepCommand } from "./generation/step-commands.js";
 export function createGenerationCommand(dependencies) {
     return new Command("generation")
         .description("Manage deterministic generation sessions")
@@ -514,5 +10,12 @@ export function createGenerationCommand(dependencies) {
         .addCommand(createStepCommand(dependencies))
         .addCommand(createConfirmCommand(dependencies))
         .addCommand(createManualCommand(dependencies))
+        .addCommand(createBridgeCommand(dependencies))
+        .addCommand(createStatusCommand(dependencies))
+        .addCommand(createRecoverCommand(dependencies))
+        .addCommand(createReopenCommand(dependencies))
+        .addCommand(createArchiveCommand(dependencies))
+        .addCommand(createConfigCommand(dependencies))
+        .addCommand(createListCommand(dependencies))
         .addCommand(createFinalizeCommand(dependencies));
 }

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

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

package/dist/cli/commands/impact.js

@@ -0,0 +1,87 @@
+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 { failureOutput, writeJson, writeLine } from "../output.js";
+function summarize(impact) {
+    const lines = [
+        `TapHound impact: ${impact.base}...${impact.head}`,
+        `affected modules: ${impact.affectedModules.join(", ") || "(none)"}`,
+        `affected features: ${impact.affectedFeatures.join(", ") || "(none)"}`,
+        `affected screens: ${impact.affectedScreens.join(", ") || "(none)"}`,
+        `affected anchors: ${impact.affectedAnchors.join(", ") || "(none)"}`,
+        "[P0]",
+        ...impact.selectedJourneys.p0.map((entry) => `  ${entry.id} — ${entry.reason}`),
+        "[P1]",
+        ...impact.selectedJourneys.p1.map((entry) => `  ${entry.id} — ${entry.reason}`),
+        "[P2]",
+        ...impact.selectedJourneys.p2.map((entry) => `  ${entry.id} — ${entry.reason}`),
+        "skipped",
+        ...impact.skippedJourneys.map((entry) => `  ${entry.id} — ${entry.reason}`)
+    ];
+    return lines.join("\n");
+}
+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 createImpactCommand(dependencies) {
+    return new Command("impact")
+        .description("Compute which Knowledge and Journeys a Git change affects")
+        .option("--project <path>", "Android project root", dependencies.cwd())
+        .option("--config <path>", "TapHound config path", CONFIG_PATH)
+        .option("--base <ref>", "Base Git ref", "origin/main")
+        .option("--head <ref>", "Head Git ref, or WORKTREE for uncommitted changes", "HEAD")
+        .option("--json", "Emit one machine-readable JSON value")
+        .action(async (options) => {
+        try {
+            if (dependencies.gitDiff === undefined
+                || dependencies.impact === undefined) {
+                throw new Error("TapHound impact is not configured");
+            }
+            const config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(options.project, options.config)));
+            const changeSet = await dependencies.gitDiff.diff({
+                projectRoot: options.project,
+                base: options.base,
+                head: options.head ?? "HEAD"
+            });
+            const impact = await dependencies.impact.resolve({
+                projectRoot: options.project,
+                packageName: config.run.packageName,
+                changeSet
+            });
+            if (options.json === true) {
+                writeJson(dependencies.stdout, impact);
+            }
+            else {
+                writeLine(dependencies.stdout, summarize(impact));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : String(error);
+            const code = failureCodeFromUnknown(error);
+            if (code !== undefined) {
+                writeFailure(dependencies, options.json === true, code, message);
+                return;
+            }
+            const output = failureOutput(2, "CONFIG_INVALID", message);
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(2);
+        }
+    });
+}

package/dist/cli/commands/init.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { SkillPayloadMissingError } from "../../adapters/filesystem/skill-installer.js";
+import { SkillPayloadMissingError, NoSkillsFoundError } from "../../adapters/filesystem/skill-installer.js";
 import { NoAgentsSelectedError, UnknownAgentError, parseAgentIds } from "../../domain/init.js";
 import { InitPromptCancelledError } from "../../ports/init-prompt.js";
 import { errorMessage, writeJson, writeLine } from "../output.js";
@@ -26,10 +26,13 @@ function writeInitSuccess(dependencies, options, result) {
     }
     else {
         const agentList = result.agents.join(", ");
-        const pathList = result.paths.join("\n  ");
-        let message = `Installed TapHound Skill for: ${agentList}\n  ${pathList}`;
-        if (result.skipped !== undefined && result.skipped.length > 0) {
-            message += `\n  Skipped (already installed): ${result.skipped.join(", ")}`;
+        let message = `Installed TapHound Skills for: ${agentList}`;
+        for (const skill of result.skills) {
+            const pathList = skill.paths.join("\n  ");
+            message += `\n  ${skill.name}:\n  ${pathList}`;
+            if (skill.skipped !== undefined && skill.skipped.length > 0) {
+                message += `\n  Skipped (already installed): ${skill.skipped.join(", ")}`;
+            }
         }
         writeLine(dependencies.stdout, message);
     }
@@ -37,7 +40,7 @@ function writeInitSuccess(dependencies, options, result) {
 }
 export function createInitCommand(dependencies) {
     return new Command("init")
-        .description("Install the TapHound AI Journey Skill for AI agents")
+        .description("Install TapHound Skills for AI agents")
         .option("--global", "Install to user-level directories instead of project-level")
         .option("--agent <ids>", "Comma-separated agent IDs (non-interactive)")
         .option("--json", "Emit one machine-readable JSON value")
@@ -94,6 +97,10 @@ export function createInitCommand(dependencies) {
                 writeInitFailure(dependencies, options, 2, "SKILL_PAYLOAD_MISSING", error);
                 return;
             }
+            if (error instanceof NoSkillsFoundError) {
+                writeInitFailure(dependencies, options, 2, "NO_SKILLS_FOUND", error);
+                return;
+            }
             if (error instanceof NoAgentsSelectedError) {
                 writeInitFailure(dependencies, options, 2, "NO_AGENTS_SELECTED", error);
                 return;

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

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