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

package/dist/domain/generation.js

@@ -1,18 +1,42 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
+import { UiBackendDescriptorSchema } from "./ui-backend.js";
+import { IdlePolicySchema } from "./config.js";
 import { JourneyStepSchema } from "./journey.js";
+import { FlowNameSchema } from "./journey-composition.js";
 import { ProjectRelativePathSchema } from "./project-context.js";
 import { InteractionPolicySchema } from "./project-context.js";
+import { ContextSelectionSchema } from "./project-context.js";
 import { ProposedStepSchema } from "./proposed-step.js";
 import { RuntimeSnapshotSchema } from "./runtime-snapshot.js";
 export const GENERATION_ERROR_CODES = [
     "CONFIG_INVALID",
     "CONTEXT_INVALID",
     "CONTEXT_STALE",
+    "BRIEF_INVALID",
+    "KNOWLEDGE_INVALID",
+    "KNOWLEDGE_STALE",
+    "ANCHOR_AMBIGUOUS",
+    "FLOW_INVALID",
+    "FLOW_REPLAY_FAILED",
+    "APP_LAUNCH_FAILED",
     "SNAPSHOT_STALE",
     "PACKAGE_ESCAPE",
+    "BRIDGE_NO_ESCAPE",
+    "SCENARIO_PACKAGE_MISMATCH",
+    "BRIDGE_NOT_RETURNED",
+    "EXTERNAL_FLOW_NOT_FOUND",
+    "EXTERNAL_FLOW_STALE",
+    "EXTERNAL_LOCATOR_STRICTNESS",
+    "EXTERNAL_PACKAGE_MISMATCH",
+    "EXTERNAL_ACTIVITY_MISMATCH",
+    "EXTERNAL_STEP_FAILED",
     "APP_CRASHED",
+    "IDLE_TIMEOUT",
+    "WINDOW_HIERARCHY_INCOMPLETE",
     "ACTION_UNSUPPORTED",
+    "LOCATOR_NOT_FOUND",
+    "LOCATOR_AMBIGUOUS",
     "RISK_CONFIRMATION_REQUIRED",
     "ACTION_FORBIDDEN",
     "EXPECT_UNSUPPORTED",
@@ -24,6 +48,29 @@ export const GENERATION_ERROR_CODES = [
 ];
 export const GenerationErrorCodeSchema = z.enum(GENERATION_ERROR_CODES);
 const Sha256Schema = z.string().regex(/^[a-f\d]{64}$/);
+export const GenerationStepSourceSchema = z.enum([
+    "flow",
+    "planner",
+    "manualOverride"
+]);
+export const GenerationBaseFlowSchema = z.strictObject({
+    name: FlowNameSchema,
+    resolutionSha256: Sha256Schema,
+    journeySha256: Sha256Schema,
+    verificationReportSha256: Sha256Schema,
+    verificationRunId: z.string().min(1),
+    stepCount: z.number().int().positive()
+});
+export const GenerationSourceBriefSchema = z.strictObject({
+    path: ProjectRelativePathSchema,
+    sha256: Sha256Schema
+});
+export const GenerationExternalFlowBindingSchema = z.strictObject({
+    name: FlowNameSchema,
+    flowSha256: Sha256Schema,
+    escapedPackageName: z.string().regex(/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/),
+    stepCount: z.number().int().positive()
+});
 export const GenerationSessionIdSchema = z.string().regex(/^[A-Za-z\d](?:[A-Za-z\d._-]*[A-Za-z\d])?$/, "Generation session id must be a safe directory name");
 const LiteralSchema = z.string().refine((value) => !value.includes("${") && !value.includes("}"), "Generation variable bindings must be literal");
 export const GenerationVariablesSchema = z.strictObject({
@@ -39,7 +86,30 @@ export const GenerationInFlightSchema = z.strictObject({
     stepIndex: z.number().int().nonnegative(),
     snapshotHash: Sha256Schema,
     proposalHash: Sha256Schema,
-    attemptId: GenerationSessionIdSchema
+    attemptId: GenerationSessionIdSchema,
+    confirmation: z.strictObject({
+        challengeId: GenerationSessionIdSchema,
+        approvalMode: z.enum(["localTty", "delegated"])
+    }).optional()
+});
+export const ConfirmationReasonSchema = z.strictObject({
+    rule: z.enum([
+        "policyActionRequiresConfirmation",
+        "actionNotAllowlisted",
+        "semanticSideEffect"
+    ]),
+    message: z.string().trim().min(1),
+    category: z.enum(["hardCommit", "destructive", "account"]).optional(),
+    matchedTerm: z.string().trim().min(1).optional()
+}).superRefine((reason, context) => {
+    const semantic = reason.rule === "semanticSideEffect";
+    if (semantic !== (reason.category !== undefined)
+        || semantic !== (reason.matchedTerm !== undefined)) {
+        context.addIssue({
+            code: "custom",
+            message: "category and matchedTerm belong to the semanticSideEffect rule"
+        });
+    }
 });
 export const PendingConfirmationSchema = z.strictObject({
     challengeId: GenerationSessionIdSchema,
@@ -48,18 +118,50 @@ export const PendingConfirmationSchema = z.strictObject({
     snapshotHash: Sha256Schema,
     evidenceHash: Sha256Schema,
     actionSummary: z.string().trim().min(1),
+    reason: ConfirmationReasonSchema.optional(),
     expiresAt: z.iso.datetime(),
-    status: z.enum(["pending", "approved"])
+    status: z.enum(["pending", "approved"]),
+    approvalMode: z.enum(["localTty", "delegated"]).optional()
 });
 const GenerationFailureSchema = z.strictObject({
     code: GenerationErrorCodeSchema,
     message: z.string().trim().min(1)
 });
+export const VerificationPhaseSchema = z.discriminatedUnion("stage", [
+    z.strictObject({ stage: z.literal("preparing") }),
+    z.strictObject({
+        stage: z.literal("replaying"),
+        stepIndex: z.number().int().nonnegative(),
+        stepCount: z.number().int().positive()
+    }).superRefine((phase, context) => {
+        if (phase.stepIndex >= phase.stepCount) {
+            context.addIssue({
+                code: "custom",
+                path: ["stepIndex"],
+                message: "Replaying phase step index must stay within the step count"
+            });
+        }
+    }),
+    z.strictObject({ stage: z.literal("collecting") })
+]);
+export function verificationPhaseLabel(phase) {
+    switch (phase.stage) {
+        case "preparing":
+            return "preparing device replay";
+        case "replaying":
+            return `replaying step ${String(phase.stepIndex + 1)}/${String(phase.stepCount)}`;
+        case "collecting":
+            return "collecting final evidence";
+    }
+}
 const VerificationSchema = z.discriminatedUnion("status", [
     z.strictObject({ status: z.literal("notRun") }),
     z.strictObject({
         status: z.literal("running"),
-        attemptId: GenerationSessionIdSchema
+        attemptId: GenerationSessionIdSchema,
+        ownerPid: z.number().int().positive().optional(),
+        startedAt: z.iso.datetime().optional(),
+        phase: VerificationPhaseSchema.optional()
     }),
     z.strictObject({
         status: z.literal("passed"),
@@ -73,6 +175,12 @@ const VerificationSchema = z.discriminatedUnion("status", [
         failure: GenerationFailureSchema
     })
 ]);
+const VerificationHistoryEntrySchema = z.strictObject({
+    failedRevision: NonnegativeSafeIntegerSchema,
+    reopenedAt: z.iso.datetime(),
+    reason: z.string().trim().min(1).max(500),
+    failure: GenerationFailureSchema
+});
 const PublicationSchema = z.discriminatedUnion("status", [
     z.strictObject({ status: z.literal("notRun") }),
     z.strictObject({
@@ -84,16 +192,16 @@ const PublicationSchema = z.discriminatedUnion("status", [
         failure: GenerationFailureSchema
     })
 ]);
-export const GenerationSessionSchema = z.strictObject({
-    version: z.literal(1),
+const GenerationSessionFields = {
     id: GenerationSessionIdSchema,
     revision: NonnegativeSafeIntegerSchema,
-    state: z.enum(["active", "recoveryRequired"]),
+    state: z.enum(["active", "recoveryRequired", "archived"]),
     bindings: z.strictObject({
         projectHash: Sha256Schema,
         configHash: Sha256Schema,
         contextHash: Sha256Schema,
-        snapshotHash: Sha256Schema.nullable()
+        snapshotHash: Sha256Schema.nullable(),
+        uiBackend: UiBackendDescriptorSchema
     }),
     target: z.strictObject({
         packageName: z.string().regex(/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/),
@@ -101,13 +209,23 @@ export const GenerationSessionSchema = z.strictObject({
         resetStrategy: z.literal("processOnly"),
         interactionPolicy: InteractionPolicySchema
     }),
+    contextSelection: ContextSelectionSchema,
+    idlePolicy: IdlePolicySchema.optional(),
     variables: GenerationVariablesSchema,
+    baseFlow: GenerationBaseFlowSchema.optional(),
+    sourceBrief: GenerationSourceBriefSchema.optional(),
+    externalFlows: z.array(GenerationExternalFlowBindingSchema),
     candidateSteps: z.array(JourneyStepSchema),
-    candidateSources: z.array(z.enum(["planner", "manualOverride"])),
+    candidateSources: z.array(GenerationStepSourceSchema),
     inFlight: GenerationInFlightSchema.nullable(),
     pendingConfirmation: PendingConfirmationSchema.nullable(),
     verification: VerificationSchema,
+    verificationHistory: z.array(VerificationHistoryEntrySchema),
     publication: PublicationSchema
+};
+export const GenerationSessionSchema = z.strictObject({
+    version: z.literal(1),
+    ...GenerationSessionFields
 }).superRefine((session, context) => {
     if (session.candidateSources.length !== session.candidateSteps.length) {
         context.addIssue({
@@ -116,6 +234,28 @@ export const GenerationSessionSchema = z.strictObject({
             message: "Candidate provenance must align exactly with candidate steps"
         });
     }
+    const flowStepCount = session.candidateSources.filter((source) => source === "flow").length;
+    if ((session.baseFlow === undefined && flowStepCount !== 0)
+        || (session.baseFlow !== undefined
+            && (flowStepCount !== session.baseFlow.stepCount
+                || session.candidateSources.slice(0, flowStepCount).some((source) => source !== "flow")))) {
+        context.addIssue({
+            code: "custom",
+            path: ["baseFlow"],
+            message: "Base Flow provenance must be a contiguous candidate prefix"
+        });
+    }
+    const externalFlowNames = new Set();
+    for (const [index, flow] of session.externalFlows.entries()) {
+        if (externalFlowNames.has(flow.name)) {
+            context.addIssue({
+                code: "custom",
+                path: ["externalFlows", index, "name"],
+                message: "External flow bindings must be unique"
+            });
+        }
+        externalFlowNames.add(flow.name);
+    }
     if (session.state === "recoveryRequired" && session.inFlight === null) {
         context.addIssue({
             code: "custom",
@@ -165,7 +305,18 @@ export const GenerationSessionSchema = z.strictObject({
             message: "Publication can only start after passed verification"
         });
     }
+    if (session.state === "archived"
+        && (session.inFlight !== null || session.pendingConfirmation !== null)) {
+        context.addIssue({
+            code: "custom",
+            path: ["state"],
+            message: "Archived sessions must not carry in-flight work or pending confirmation"
+        });
+    }
 });
+export function isGenerationConfirmationExpired(challenge, now) {
+    return now.getTime() >= new Date(challenge.expiresAt).getTime();
+}
 export const GenerationConfirmationEvidenceSchema = z.strictObject({
     version: z.literal(1),
     proposal: ProposedStepSchema,
@@ -207,21 +358,55 @@ const BundleRelativePathSchema = z.string().min(1).superRefine((path, context) =
 });
 export const GenerationMetaSchema = z.strictObject({
     version: z.literal(1),
-    status: z.literal("verified"),
+    status: z.enum(["verified", "promoted"]),
+    promotion: z.strictObject({
+        promotedAt: z.iso.datetime(),
+        reason: z.string().trim().min(1)
+    }).optional(),
+    retired: z.strictObject({
+        retiredAt: z.iso.datetime(),
+        reason: z.string().trim().min(1)
+    }).optional(),
     generationId: GenerationSessionIdSchema,
     journeyPath: ProjectRelativePathSchema,
+    journeySha256: Sha256Schema,
     bindings: z.strictObject({
         projectHash: Sha256Schema,
         configHash: Sha256Schema,
-        contextHash: Sha256Schema
+        contextHash: Sha256Schema,
+        uiBackend: UiBackendDescriptorSchema
     }),
+    replayPolicy: z.strictObject({
+        generatedReplayPolicy: z.boolean(),
+        requireFocusedInput: z.boolean(),
+        idle: IdlePolicySchema
+    }),
+    contextSelection: ContextSelectionSchema,
     verification: z.strictObject({
         reportPath: BundleRelativePathSchema,
         reportSha256: Sha256Schema,
         runId: z.string().min(1),
         runs: z.literal(1)
     }),
+    baseFlow: GenerationBaseFlowSchema.optional(),
+    sourceBrief: GenerationSourceBriefSchema.optional(),
+    externalFlows: z.array(GenerationExternalFlowBindingSchema),
     manualOverrideStepIndexes: z.array(z.number().int().nonnegative())
+}).superRefine((meta, context) => {
+    if (meta.status === "verified" && meta.promotion !== undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["promotion"],
+            message: "Only promoted Journeys carry promotion details"
+        });
+    }
+    if (meta.status === "promoted" && meta.promotion === undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["promotion"],
+            message: "Promoted Journeys require promotion details"
+        });
+    }
 });
 export const GenerationReportSchema = z.strictObject({
     version: z.literal(1),
@@ -229,7 +414,7 @@ export const GenerationReportSchema = z.strictObject({
     status: z.literal("verified"),
     steps: z.array(z.strictObject({
         index: z.number().int().nonnegative(),
-        source: z.enum(["planner", "manualOverride"])
+        source: GenerationStepSourceSchema
     })).min(1)
 }).superRefine((report, context) => {
     for (const [index, step] of report.steps.entries()) {
@@ -277,10 +462,14 @@ export function generationCoreIdentity(session) {
         bindings: {
             projectHash: session.bindings.projectHash,
             configHash: session.bindings.configHash,
-            contextHash: session.bindings.contextHash
+            contextHash: session.bindings.contextHash,
+            uiBackend: session.bindings.uiBackend
         },
         target: session.target,
-        variables: session.variables
+        contextSelection: session.contextSelection,
+        variables: session.variables,
+        ...(session.baseFlow === undefined ? {} : { baseFlow: session.baseFlow }),
+        externalFlows: session.externalFlows
     };
 }
 export function bindGenerationVariables(input) {

package/dist/domain/geometry.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const PointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export type Point = z.infer<typeof PointSchema>;
+export declare const DisplayViewportSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    rotation: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<90>, z.ZodLiteral<180>, z.ZodLiteral<270>]>;
+    coordinateSpace: z.ZodLiteral<"physicalDisplayPixels">;
+}, z.core.$strict>;
+export type DisplayViewport = z.infer<typeof DisplayViewportSchema>;

package/dist/domain/geometry.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const PointSchema = z.strictObject({
+    x: z.number().int().nonnegative(),
+    y: z.number().int().nonnegative()
+});
+export const DisplayViewportSchema = z.strictObject({
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    rotation: z.union([
+        z.literal(0),
+        z.literal(90),
+        z.literal(180),
+        z.literal(270)
+    ]),
+    coordinateSpace: z.literal("physicalDisplayPixels")
+});

package/dist/domain/impact.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const ChangedFileStatusSchema: z.ZodEnum<{
+    added: "added";
+    modified: "modified";
+    deleted: "deleted";
+    renamed: "renamed";
+}>;
+export declare const ChangedFileSchema: z.ZodObject<{
+    path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    status: z.ZodEnum<{
+        added: "added";
+        modified: "modified";
+        deleted: "deleted";
+        renamed: "renamed";
+    }>;
+    oldPath: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+}, z.core.$strict>;
+export declare const ChangeSetSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    base: z.ZodString;
+    head: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        status: z.ZodEnum<{
+            added: "added";
+            modified: "modified";
+            deleted: "deleted";
+            renamed: "renamed";
+        }>;
+        oldPath: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const JourneySelectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare const ImpactSetSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    base: z.ZodString;
+    head: z.ZodString;
+    affectedModules: z.ZodArray<z.ZodString>;
+    affectedFeatures: z.ZodArray<z.ZodString>;
+    affectedScreens: z.ZodArray<z.ZodString>;
+    affectedAnchors: z.ZodArray<z.ZodString>;
+    selectedJourneys: z.ZodObject<{
+        p0: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        p1: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        p2: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    skippedJourneys: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    provenance: z.ZodObject<{
+        contextHash: z.ZodString;
+        knowledgeHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ChangeSet = z.infer<typeof ChangeSetSchema>;
+export type ChangedFile = z.infer<typeof ChangedFileSchema>;
+export type ImpactSet = z.infer<typeof ImpactSetSchema>;
+export type JourneySelection = z.infer<typeof JourneySelectionSchema>;

package/dist/domain/impact.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { KnowledgeIdSchema } from "./knowledge.js";
+import { ProjectRelativePathSchema } from "./project-context.js";
+export const ChangedFileStatusSchema = z.enum([
+    "added",
+    "modified",
+    "deleted",
+    "renamed"
+]);
+export const ChangedFileSchema = z.strictObject({
+    path: ProjectRelativePathSchema,
+    status: ChangedFileStatusSchema,
+    oldPath: ProjectRelativePathSchema.optional()
+}).superRefine((file, context) => {
+    if (file.status === "renamed" && file.oldPath === undefined) {
+        context.addIssue({
+            code: "custom",
+            path: ["oldPath"],
+            message: "A renamed file must declare its old path"
+        });
+    }
+    if (file.oldPath === file.path) {
+        context.addIssue({
+            code: "custom",
+            path: ["oldPath"],
+            message: "A renamed file cannot keep its own path"
+        });
+    }
+});
+export const ChangeSetSchema = z.strictObject({
+    version: z.literal(1),
+    base: z.string().trim().min(1),
+    head: z.string().trim().min(1),
+    files: z.array(ChangedFileSchema).min(1)
+}).superRefine((changeSet, context) => {
+    const allPaths = new Set();
+    for (const [index, file] of changeSet.files.entries()) {
+        const candidates = [
+            file.path,
+            ...(file.oldPath === undefined ? [] : [file.oldPath])
+        ];
+        for (const path of candidates) {
+            if (allPaths.has(path)) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["files", index, "path"],
+                    message: `ChangeSet path ${path} appears more than once`
+                });
+            }
+            allPaths.add(path);
+        }
+    }
+});
+export const JourneySelectionSchema = z.strictObject({
+    id: z.string().trim().min(1),
+    reason: z.string().trim().min(1)
+});
+export const ImpactSetSchema = z.strictObject({
+    version: z.literal(1),
+    base: z.string().trim().min(1),
+    head: z.string().trim().min(1),
+    affectedModules: z.array(z.string().trim().min(1)),
+    affectedFeatures: z.array(z.string().trim().min(1)),
+    affectedScreens: z.array(KnowledgeIdSchema),
+    affectedAnchors: z.array(KnowledgeIdSchema),
+    selectedJourneys: z.strictObject({
+        p0: z.array(JourneySelectionSchema),
+        p1: z.array(JourneySelectionSchema),
+        p2: z.array(JourneySelectionSchema)
+    }),
+    skippedJourneys: z.array(JourneySelectionSchema),
+    provenance: z.strictObject({
+        contextHash: z.string().regex(/^[a-f\d]{64}$/),
+        knowledgeHash: z.string().regex(/^[a-f\d]{64}$/)
+    })
+});

package/dist/domain/init.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-export declare const SKILL_DIRECTORY_NAME = "taphound-ai-journey";
 export declare const AGENT_IDS: readonly ["claude", "codex", "cursor", "droid", "other"];
 export type AgentId = (typeof AGENT_IDS)[number];
 export declare const AgentIdSchema: z.ZodEnum<{
@@ -26,17 +25,26 @@ export declare class NoAgentsSelectedError extends Error {
     constructor();
 }
 export interface TargetPath {
+    readonly skillName: string;
     readonly absolutePath: string;
     readonly relativePath: string;
     readonly agents: AgentId[];
     readonly skipped: boolean;
 }
-export declare function resolveTargetPaths(agents: readonly AgentId[], global: boolean, cwd: string, homedir: string): TargetPath[];
+export declare function resolveTargetPaths(skillNames: readonly string[], agents: readonly AgentId[], global: boolean, cwd: string, homedir: string): TargetPath[];
+export interface SkillInstallGroup {
+    readonly name: string;
+    readonly paths: string[];
+    readonly skipped: string[];
+}
 export declare const InitResultSchema: z.ZodObject<{
     status: z.ZodLiteral<"installed">;
     exitCode: z.ZodLiteral<0>;
     agents: z.ZodArray<z.ZodString>;
-    paths: z.ZodArray<z.ZodString>;
-    skipped: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        paths: z.ZodArray<z.ZodString>;
+        skipped: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type InitResult = z.infer<typeof InitResultSchema>;

package/dist/domain/init.js

@@ -1,6 +1,5 @@
 import { resolve } from "node:path";
 import { z } from "zod";
-export const SKILL_DIRECTORY_NAME = "taphound-ai-journey";
 export const AGENT_IDS = [
     "claude",
     "codex",
@@ -77,28 +76,32 @@ export class NoAgentsSelectedError extends Error {
         this.name = "NoAgentsSelectedError";
     }
 }
-export function resolveTargetPaths(agents, global, cwd, homedir) {
+export function resolveTargetPaths(skillNames, agents, global, cwd, homedir) {
     if (agents.length === 0) {
         throw new NoAgentsSelectedError();
     }
     const map = new Map();
-    for (const id of agents) {
-        const definition = findAgentDefinition(id);
-        const baseDir = global ? definition.globalPath : definition.projectPath;
-        const relativePath = `${baseDir}/${SKILL_DIRECTORY_NAME}`;
-        const absolutePath = resolve(global ? homedir : cwd, relativePath);
-        const existing = map.get(absolutePath);
-        if (existing === undefined) {
-            map.set(absolutePath, {
-                relativePath,
-                agents: [id]
-            });
-        }
-        else {
-            existing.agents.push(id);
+    for (const skillName of skillNames) {
+        for (const id of agents) {
+            const definition = findAgentDefinition(id);
+            const baseDir = global ? definition.globalPath : definition.projectPath;
+            const relativePath = `${baseDir}/${skillName}`;
+            const absolutePath = resolve(global ? homedir : cwd, relativePath);
+            const existing = map.get(absolutePath);
+            if (existing === undefined) {
+                map.set(absolutePath, {
+                    skillName,
+                    relativePath,
+                    agents: [id]
+                });
+            }
+            else {
+                existing.agents.push(id);
+            }
         }
     }
     return [...map.entries()].map(([absolutePath, entry]) => ({
+        skillName: entry.skillName,
         absolutePath,
         relativePath: entry.relativePath,
         agents: entry.agents,
@@ -109,6 +112,9 @@ export const InitResultSchema = z.strictObject({
     status: z.literal("installed"),
     exitCode: z.literal(0),
     agents: z.array(z.string()),
-    paths: z.array(z.string()),
-    skipped: z.array(z.string()).optional()
+    skills: z.array(z.strictObject({
+        name: z.string(),
+        paths: z.array(z.string()),
+        skipped: z.array(z.string()).optional()
+    }))
 });