@shahmarasy/prodo 0.1.4 → 0.1.6

package/dist/skill-engine/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInputPaths = exports.validateOutputs = exports.validateInputs = exports.discoverSkills = exports.getExecutionOrder = exports.detectCycles = exports.buildExecutionPlan = exports.hydrateStateFromDisk = exports.createPipelineState = exports.SkillRegistry = exports.SkillPipeline = void 0;
+exports.createEngine = createEngine;
+exports.createHydratedState = createHydratedState;
+const registry_1 = require("./registry");
+const pipeline_1 = require("./pipeline");
+const discovery_1 = require("./discovery");
+const register_core_1 = require("../skills/register-core");
+const context_1 = require("./context");
+const artifact_registry_1 = require("../core/artifact-registry");
+async function createEngine(cwd, log) {
+    const registry = new registry_1.SkillRegistry();
+    await (0, register_core_1.registerCoreSkills)(registry, cwd);
+    const plugins = await (0, discovery_1.discoverSkills)(cwd, log);
+    for (const plugin of plugins) {
+        try {
+            registry.register(plugin);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log?.(`[Skill Engine] Plugin registration failed: ${message}`);
+        }
+    }
+    return new pipeline_1.SkillPipeline(registry);
+}
+async function createHydratedState(cwd) {
+    const state = (0, context_1.createPipelineState)(cwd);
+    const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
+    await (0, context_1.hydrateStateFromDisk)(cwd, state, artifactTypes);
+    return state;
+}
+var pipeline_2 = require("./pipeline");
+Object.defineProperty(exports, "SkillPipeline", { enumerable: true, get: function () { return pipeline_2.SkillPipeline; } });
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "SkillRegistry", { enumerable: true, get: function () { return registry_2.SkillRegistry; } });
+var context_2 = require("./context");
+Object.defineProperty(exports, "createPipelineState", { enumerable: true, get: function () { return context_2.createPipelineState; } });
+Object.defineProperty(exports, "hydrateStateFromDisk", { enumerable: true, get: function () { return context_2.hydrateStateFromDisk; } });
+var graph_1 = require("./graph");
+Object.defineProperty(exports, "buildExecutionPlan", { enumerable: true, get: function () { return graph_1.buildExecutionPlan; } });
+Object.defineProperty(exports, "detectCycles", { enumerable: true, get: function () { return graph_1.detectCycles; } });
+Object.defineProperty(exports, "getExecutionOrder", { enumerable: true, get: function () { return graph_1.getExecutionOrder; } });
+var discovery_2 = require("./discovery");
+Object.defineProperty(exports, "discoverSkills", { enumerable: true, get: function () { return discovery_2.discoverSkills; } });
+var validator_1 = require("./validator");
+Object.defineProperty(exports, "validateInputs", { enumerable: true, get: function () { return validator_1.validateInputs; } });
+Object.defineProperty(exports, "validateOutputs", { enumerable: true, get: function () { return validator_1.validateOutputs; } });
+Object.defineProperty(exports, "validateInputPaths", { enumerable: true, get: function () { return validator_1.validateInputPaths; } });

package/dist/skill-engine/pipeline.d.ts

@@ -0,0 +1,9 @@
+import type { SkillRegistry } from "./registry";
+import type { PipelineOptions, PipelineState } from "./types";
+export declare class SkillPipeline {
+    private registry;
+    constructor(registry: SkillRegistry);
+    runPipeline(skillNames: string[], state: PipelineState, options?: PipelineOptions): Promise<PipelineState>;
+    runSkill(name: string, state: PipelineState, options?: PipelineOptions): Promise<PipelineState>;
+    getRegistry(): SkillRegistry;
+}

package/dist/skill-engine/pipeline.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillPipeline = void 0;
+const errors_1 = require("../core/errors");
+const context_1 = require("./context");
+const graph_1 = require("./graph");
+const validator_1 = require("./validator");
+function createSkillError(skillName, phase, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : undefined;
+    return {
+        skillName,
+        phase,
+        message,
+        stack,
+        recoveryHints: [`Skill "${skillName}" failed during ${phase}. Check inputs and retry.`]
+    };
+}
+class SkillPipeline {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async runPipeline(skillNames, state, options = {}) {
+        const { log = console.log, progress, agent } = options;
+        for (const name of skillNames) {
+            if (!this.registry.has(name)) {
+                const available = this.registry.list().map((s) => s.manifest.name).join(", ");
+                throw new errors_1.UserError(`Unknown skill: "${name}". Available: ${available}`);
+            }
+        }
+        const manifests = new Map(this.registry.list().map((s) => [s.manifest.name, s.manifest]));
+        const executionOrder = (0, graph_1.getExecutionOrder)(manifests, skillNames);
+        const totalSteps = executionOrder.length;
+        for (let i = 0; i < executionOrder.length; i++) {
+            const skillName = executionOrder[i];
+            if (state.completedSkills.includes(skillName)) {
+                log(`[Skip] ${skillName} — already completed`);
+                continue;
+            }
+            const skill = this.registry.get(skillName);
+            if (!skill)
+                continue;
+            progress?.(i + 1, totalSteps, `Running ${skillName}...`);
+            log(`[${i + 1}/${totalSteps}] ${skillName}`);
+            const inputNames = skill.manifest.inputs.map((inp) => inp.name);
+            const wiredInputs = (0, context_1.wireInputsFromState)(inputNames, state);
+            const inputError = (0, validator_1.validateInputs)(skill.manifest, wiredInputs);
+            if (inputError) {
+                throw new errors_1.UserError(`Skill "${skillName}" input validation failed: ${inputError.message}\n` +
+                    inputError.recoveryHints.join("\n"));
+            }
+            let outputs;
+            try {
+                const context = {
+                    state,
+                    progress: progress ?? (() => { }),
+                    log,
+                    agent
+                };
+                outputs = await skill.execute(context, wiredInputs);
+            }
+            catch (error) {
+                const skillError = createSkillError(skillName, "execution", error);
+                throw new errors_1.UserError(`Skill "${skillName}" execution failed: ${skillError.message}\n` +
+                    skillError.recoveryHints.join("\n"));
+            }
+            const outputError = (0, validator_1.validateOutputs)(skill.manifest, outputs);
+            if (outputError) {
+                log(`[Warning] Skill "${skillName}" output validation: ${outputError.message}`);
+            }
+            (0, context_1.wireOutputsToState)(outputs, state, skillName);
+            state.completedSkills.push(skillName);
+        }
+        return state;
+    }
+    async runSkill(name, state, options = {}) {
+        return this.runPipeline([name], state, options);
+    }
+    getRegistry() {
+        return this.registry;
+    }
+}
+exports.SkillPipeline = SkillPipeline;

package/dist/skill-engine/registry.d.ts

@@ -0,0 +1,12 @@
+import type { Skill, SkillManifest } from "./types";
+export declare class SkillRegistry {
+    private skills;
+    register(skill: Skill): void;
+    get(name: string): Skill | undefined;
+    has(name: string): boolean;
+    list(): Skill[];
+    listByCategory(category: string): Skill[];
+    listManifests(): SkillManifest[];
+    unregister(name: string): boolean;
+    size(): number;
+}

package/dist/skill-engine/registry.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillRegistry = void 0;
+const errors_1 = require("../core/errors");
+function validateManifest(manifest) {
+    if (!manifest.name || typeof manifest.name !== "string")
+        return "Skill name is required";
+    if (!manifest.version || typeof manifest.version !== "string")
+        return "Skill version is required";
+    if (!manifest.description || typeof manifest.description !== "string")
+        return "Skill description is required";
+    const validCategories = ["core", "artifact", "validation", "custom"];
+    if (!validCategories.includes(manifest.category)) {
+        return `Invalid category "${manifest.category}". Must be: ${validCategories.join(", ")}`;
+    }
+    if (!Array.isArray(manifest.depends_on))
+        return "depends_on must be an array";
+    if (!Array.isArray(manifest.inputs))
+        return "inputs must be an array";
+    if (!Array.isArray(manifest.outputs))
+        return "outputs must be an array";
+    const validTypes = ["string", "path", "boolean", "json", "number"];
+    for (const input of manifest.inputs) {
+        if (!input.name || typeof input.name !== "string")
+            return "Input name is required";
+        if (!validTypes.includes(input.type))
+            return `Invalid input type "${input.type}" for "${input.name}"`;
+    }
+    for (const output of manifest.outputs) {
+        if (!output.name || typeof output.name !== "string")
+            return "Output name is required";
+        if (!validTypes.includes(output.type))
+            return `Invalid output type "${output.type}" for "${output.name}"`;
+    }
+    return null;
+}
+class SkillRegistry {
+    skills = new Map();
+    register(skill) {
+        const error = validateManifest(skill.manifest);
+        if (error) {
+            throw new errors_1.UserError(`Invalid skill manifest for "${skill.manifest?.name ?? "unknown"}": ${error}`);
+        }
+        if (typeof skill.execute !== "function") {
+            throw new errors_1.UserError(`Skill "${skill.manifest.name}" must export an execute function`);
+        }
+        if (this.skills.has(skill.manifest.name)) {
+            throw new errors_1.UserError(`Skill "${skill.manifest.name}" is already registered`);
+        }
+        this.skills.set(skill.manifest.name, skill);
+    }
+    get(name) {
+        return this.skills.get(name);
+    }
+    has(name) {
+        return this.skills.has(name);
+    }
+    list() {
+        return Array.from(this.skills.values());
+    }
+    listByCategory(category) {
+        return this.list().filter((s) => s.manifest.category === category);
+    }
+    listManifests() {
+        return this.list().map((s) => s.manifest);
+    }
+    unregister(name) {
+        return this.skills.delete(name);
+    }
+    size() {
+        return this.skills.size;
+    }
+}
+exports.SkillRegistry = SkillRegistry;

package/dist/skill-engine/types.d.ts

@@ -0,0 +1,66 @@
+import type { ValidationIssue } from "../core/types";
+export type SkillInputType = "string" | "path" | "boolean" | "json" | "number";
+export type SkillInput = {
+    name: string;
+    type: SkillInputType;
+    required: boolean;
+    description?: string;
+    default?: unknown;
+};
+export type SkillOutput = {
+    name: string;
+    type: SkillInputType;
+    description?: string;
+};
+export type SkillManifest = {
+    name: string;
+    version: string;
+    description: string;
+    category: "core" | "artifact" | "validation" | "custom";
+    depends_on: string[];
+    inputs: SkillInput[];
+    outputs: SkillOutput[];
+    tags?: string[];
+};
+export type PipelineState = {
+    cwd: string;
+    normalizedBriefPath?: string;
+    generatedArtifacts: Map<string, string>;
+    validationResult?: {
+        pass: boolean;
+        reportPath: string;
+        issues: ValidationIssue[];
+    };
+    custom: Record<string, unknown>;
+    startedAt: string;
+    completedSkills: string[];
+};
+export type ProgressCallback = (step: number, total: number, message: string) => void;
+export type SkillContext = {
+    state: PipelineState;
+    progress: ProgressCallback;
+    log: (message: string) => void;
+    agent?: string;
+};
+export type SkillExecuteFn = (context: SkillContext, inputs: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export type Skill = {
+    manifest: SkillManifest;
+    execute: SkillExecuteFn;
+};
+export type SkillError = {
+    skillName: string;
+    phase: "input_validation" | "execution" | "output_validation";
+    message: string;
+    inputContext?: Record<string, unknown>;
+    stack?: string;
+    recoveryHints: string[];
+};
+export type ExecutionTier = {
+    tier: number;
+    skills: string[];
+};
+export type PipelineOptions = {
+    log?: (message: string) => void;
+    progress?: ProgressCallback;
+    agent?: string;
+};

package/dist/skill-engine/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/skill-engine/validator.d.ts

@@ -0,0 +1,4 @@
+import type { SkillError, SkillManifest } from "./types";
+export declare function validateInputs(manifest: SkillManifest, inputs: Record<string, unknown>): SkillError | null;
+export declare function validateInputPaths(manifest: SkillManifest, inputs: Record<string, unknown>): Promise<SkillError | null>;
+export declare function validateOutputs(manifest: SkillManifest, outputs: Record<string, unknown>): SkillError | null;

package/dist/skill-engine/validator.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInputs = validateInputs;
+exports.validateInputPaths = validateInputPaths;
+exports.validateOutputs = validateOutputs;
+const utils_1 = require("../core/utils");
+function makeError(skillName, phase, message, hints = []) {
+    return {
+        skillName,
+        phase,
+        message,
+        recoveryHints: hints
+    };
+}
+function checkType(value, expectedType, fieldName) {
+    switch (expectedType) {
+        case "string":
+            if (typeof value !== "string")
+                return `"${fieldName}" must be a string, got ${typeof value}`;
+            return null;
+        case "path":
+            if (typeof value !== "string")
+                return `"${fieldName}" must be a path (string), got ${typeof value}`;
+            return null;
+        case "boolean":
+            if (typeof value !== "boolean")
+                return `"${fieldName}" must be a boolean, got ${typeof value}`;
+            return null;
+        case "number":
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                return `"${fieldName}" must be a finite number, got ${typeof value}`;
+            }
+            return null;
+        case "json":
+            if (typeof value === "string") {
+                try {
+                    JSON.parse(value);
+                }
+                catch {
+                    return `"${fieldName}" must be valid JSON string`;
+                }
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+function validateInputs(manifest, inputs) {
+    for (const input of manifest.inputs) {
+        const value = inputs[input.name];
+        if (input.required && (value === undefined || value === null)) {
+            if (input.default !== undefined)
+                continue;
+            return makeError(manifest.name, "input_validation", `Required input "${input.name}" is missing`, [`Provide "${input.name}" (${input.type}): ${input.description ?? ""}`]);
+        }
+        if (value === undefined || value === null)
+            continue;
+        const typeError = checkType(value, input.type, input.name);
+        if (typeError) {
+            return makeError(manifest.name, "input_validation", typeError, [`Expected type: ${input.type}`]);
+        }
+    }
+    return null;
+}
+async function validateInputPaths(manifest, inputs) {
+    for (const input of manifest.inputs) {
+        if (input.type !== "path")
+            continue;
+        const value = inputs[input.name];
+        if (typeof value !== "string")
+            continue;
+        if (input.required && !(await (0, utils_1.fileExists)(value))) {
+            return makeError(manifest.name, "input_validation", `Path "${input.name}" does not exist: ${value}`, [`Ensure the file or directory exists: ${value}`]);
+        }
+    }
+    return null;
+}
+function validateOutputs(manifest, outputs) {
+    for (const output of manifest.outputs) {
+        const value = outputs[output.name];
+        if (value === undefined || value === null) {
+            return makeError(manifest.name, "output_validation", `Expected output "${output.name}" was not produced`, [`Skill "${manifest.name}" should return "${output.name}" (${output.type})`]);
+        }
+        const typeError = checkType(value, output.type, output.name);
+        if (typeError) {
+            return makeError(manifest.name, "output_validation", typeError, [`Skill "${manifest.name}" returned wrong type for "${output.name}"`]);
+        }
+    }
+    return null;
+}

package/dist/skills/engine.d.ts

@@ -0,0 +1,10 @@
+import type { Skill, SkillContext, SkillManifest } from "./types";
+export type SkillEngine = {
+    register(skill: Skill): void;
+    getSkill(name: string): Skill | undefined;
+    listSkills(): SkillManifest[];
+    execute(name: string, context: SkillContext, inputs: Record<string, unknown>): Promise<Record<string, unknown>>;
+};
+export declare function createSkillEngine(): SkillEngine;
+export declare function getGlobalSkillEngine(): SkillEngine;
+export declare function resetGlobalSkillEngine(): void;

package/dist/skills/engine.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkillEngine = createSkillEngine;
+exports.getGlobalSkillEngine = getGlobalSkillEngine;
+exports.resetGlobalSkillEngine = resetGlobalSkillEngine;
+const errors_1 = require("../core/errors");
+function validateInputs(skill, inputs) {
+    for (const input of skill.manifest.inputs) {
+        if (input.required && !(input.name in inputs)) {
+            throw new errors_1.UserError(`Skill "${skill.manifest.name}" requires input "${input.name}" (${input.description})`);
+        }
+    }
+}
+function createSkillEngine() {
+    const skills = new Map();
+    return {
+        register(skill) {
+            skills.set(skill.manifest.name, skill);
+        },
+        getSkill(name) {
+            return skills.get(name);
+        },
+        listSkills() {
+            return Array.from(skills.values()).map((s) => s.manifest);
+        },
+        async execute(name, context, inputs) {
+            const skill = skills.get(name);
+            if (!skill) {
+                const available = Array.from(skills.keys()).join(", ");
+                throw new errors_1.UserError(`Unknown skill: "${name}". Available: ${available}`);
+            }
+            validateInputs(skill, inputs);
+            return skill.execute(context, inputs);
+        }
+    };
+}
+let globalEngine = null;
+function getGlobalSkillEngine() {
+    if (!globalEngine) {
+        globalEngine = createSkillEngine();
+        loadBuiltinSkills(globalEngine);
+    }
+    return globalEngine;
+}
+function resetGlobalSkillEngine() {
+    globalEngine = null;
+}
+function loadBuiltinSkills(engine) {
+    // Lazy-load to avoid circular dependencies
+    try {
+        const { normalizeSkill } = require("./normalize-skill");
+        engine.register(normalizeSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { validateSkill } = require("./validate-skill");
+        engine.register(validateSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { fixSkill } = require("./fix-skill");
+        engine.register(fixSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { generateArtifactSkill } = require("./generate-artifact-skill");
+        engine.register(generateArtifactSkill);
+    }
+    catch { /* skill not available */ }
+    try {
+        const { generatePipelineSkill } = require("./generate-pipeline-skill");
+        engine.register(generatePipelineSkill);
+    }
+    catch { /* skill not available */ }
+}

package/dist/skills/fix-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const fixSkill: Skill;

package/dist/skills/fix-skill.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixSkill = void 0;
+const fix_1 = require("../core/fix");
+exports.fixSkill = {
+    manifest: {
+        name: "fix",
+        description: "Auto-regenerate artifacts that failed validation with backup and rollback",
+        category: "validation",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "agent", type: "string", required: false, description: "Agent profile name" },
+            { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" },
+            { name: "dryRun", type: "boolean", required: false, description: "Preview without applying" }
+        ],
+        outputs: [
+            { name: "applied", type: "string", description: "Whether fix was applied" },
+            { name: "finalPass", type: "string", description: "Whether validation passed after fix" },
+            { name: "reportPath", type: "path", description: "Path to validation report" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const result = await (0, fix_1.runFix)({
+            cwd,
+            agent: inputs.agent ?? context.agent,
+            strict: Boolean(inputs.strict),
+            dryRun: Boolean(inputs.dryRun),
+            log: context.log
+        });
+        return {
+            applied: result.applied,
+            finalPass: result.finalPass,
+            reportPath: result.reportPath,
+            targetCount: result.proposal.targets.length
+        };
+    }
+};

package/dist/skills/fix.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "../skill-engine/types";
+export declare const fixSkill: Skill;

package/dist/skills/fix.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixSkill = void 0;
+const fix_1 = require("../core/fix");
+exports.fixSkill = {
+    manifest: {
+        name: "fix",
+        version: "2.0.0",
+        description: "Auto-regenerate failing artifacts with backup, proposal, and validation",
+        category: "validation",
+        depends_on: [],
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" }
+        ],
+        outputs: [
+            { name: "validationResult", type: "json", description: "Final validation result after fix" }
+        ],
+        tags: ["fix", "repair", "validation"]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.state.cwd;
+        context.progress(1, 3, "Running fix pipeline...");
+        const result = await (0, fix_1.runFix)({
+            cwd,
+            agent: context.agent,
+            log: context.log
+        });
+        context.progress(3, 3, result.finalPass ? "Fix complete." : "Fix applied, issues remain.");
+        context.state.validationResult = result.finalPass
+            ? { pass: true, reportPath: result.reportPath, issues: [] }
+            : undefined;
+        return {
+            validationResult: {
+                pass: result.finalPass,
+                reportPath: result.reportPath,
+                applied: result.applied,
+                targetCount: result.proposal.targets.length
+            }
+        };
+    }
+};

package/dist/skills/generate-artifact-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const generateArtifactSkill: Skill;

package/dist/skills/generate-artifact-skill.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateArtifactSkill = void 0;
+const artifacts_1 = require("../core/artifacts");
+exports.generateArtifactSkill = {
+    manifest: {
+        name: "generate-artifact",
+        description: "Generate a single artifact (PRD, workflow, wireframe, stories, techspec)",
+        category: "artifact",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "artifactType", type: "string", required: true, description: "Artifact type to generate" },
+            { name: "from", type: "path", required: false, description: "Override path to normalized-brief.json" },
+            { name: "out", type: "path", required: false, description: "Override output path" }
+        ],
+        outputs: [
+            { name: "filePath", type: "path", description: "Path to generated artifact" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const filePath = await (0, artifacts_1.generateArtifact)({
+            artifactType: inputs.artifactType,
+            cwd,
+            normalizedBriefOverride: inputs.from,
+            outPath: inputs.out,
+            agent: context.agent
+        });
+        context.log(`${inputs.artifactType.toUpperCase()} generated: ${filePath}`);
+        return { filePath };
+    }
+};

package/dist/skills/generate-artifact.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "../skill-engine/types";
+export declare function createArtifactSkill(artifactType: string, upstream?: string[]): Skill;

package/dist/skills/generate-artifact.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArtifactSkill = createArtifactSkill;
+const artifacts_1 = require("../core/artifacts");
+const constants_1 = require("../core/constants");
+function createArtifactSkill(artifactType, upstream) {
+    const resolvedUpstream = upstream ?? (0, constants_1.defaultUpstreamByArtifact)(artifactType);
+    const depends_on = ["normalize", ...resolvedUpstream];
+    const manifest = {
+        name: artifactType,
+        version: "2.0.0",
+        description: `Generate ${artifactType} artifact from normalized brief`,
+        category: "artifact",
+        depends_on,
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "normalizedBriefPath", type: "path", required: false, description: "Path to normalized brief" }
+        ],
+        outputs: [
+            { name: "artifactPath", type: "path", description: `Path to generated ${artifactType}` }
+        ],
+        tags: ["artifact", artifactType]
+    };
+    return {
+        manifest,
+        async execute(context, inputs) {
+            const cwd = inputs.cwd ?? context.state.cwd;
+            const normalizedBriefOverride = inputs.normalizedBriefPath ?? context.state.normalizedBriefPath;
+            context.progress(1, 2, `Generating ${artifactType}...`);
+            const filePath = await (0, artifacts_1.generateArtifact)({
+                artifactType,
+                cwd,
+                normalizedBriefOverride,
+                agent: context.agent
+            });
+            context.progress(2, 2, `${artifactType} generated.`);
+            context.log(`${artifactType.toUpperCase()} generated: ${filePath}`);
+            context.state.generatedArtifacts.set(artifactType, filePath);
+            return { artifactPath: filePath };
+        }
+    };
+}

package/dist/skills/generate-pipeline-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const generatePipelineSkill: Skill;