@shahmarasy/prodo 0.1.5 → 0.1.7

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/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.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/normalize.d.ts

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

package/dist/skills/normalize.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSkill = void 0;
+const normalize_1 = require("../core/normalize");
+exports.normalizeSkill = {
+    manifest: {
+        name: "normalize",
+        version: "2.0.0",
+        description: "Normalize a product brief into structured JSON with contracts and confidence scores",
+        category: "core",
+        depends_on: [],
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" }
+        ],
+        outputs: [
+            { name: "normalizedBriefPath", type: "path", description: "Path to normalized-brief.json" }
+        ],
+        tags: ["brief", "normalization"]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.state.cwd;
+        context.progress(1, 2, "Normalizing brief...");
+        const outPath = await (0, normalize_1.runNormalize)({ cwd });
+        context.progress(2, 2, "Brief normalized.");
+        context.log(`Normalized brief written to: ${outPath}`);
+        context.state.normalizedBriefPath = outPath;
+        return { normalizedBriefPath: outPath };
+    }
+};

package/dist/skills/register-core.d.ts

@@ -0,0 +1,2 @@
+import type { SkillRegistry } from "../skill-engine/registry";
+export declare function registerCoreSkills(registry: SkillRegistry, cwd: string): Promise<void>;

package/dist/skills/register-core.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCoreSkills = registerCoreSkills;
+const artifact_registry_1 = require("../core/artifact-registry");
+const generate_artifact_1 = require("./generate-artifact");
+const fix_1 = require("./fix");
+const normalize_1 = require("./normalize");
+const validate_1 = require("./validate");
+async function registerCoreSkills(registry, cwd) {
+    registry.register(normalize_1.normalizeSkill);
+    const definitions = await (0, artifact_registry_1.listArtifactDefinitions)(cwd);
+    const artifactNames = [];
+    for (const def of definitions) {
+        const skill = (0, generate_artifact_1.createArtifactSkill)(def.name, def.upstream);
+        registry.register(skill);
+        artifactNames.push(def.name);
+    }
+    const validateSkill = (0, validate_1.createValidateSkill)(artifactNames);
+    registry.register(validateSkill);
+    registry.register(fix_1.fixSkill);
+}

package/dist/skills/validate.d.ts

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

package/dist/skills/validate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidateSkill = createValidateSkill;
+const validate_1 = require("../core/validate");
+function createValidateSkill(artifactTypes) {
+    return {
+        manifest: {
+            name: "validate",
+            version: "2.0.0",
+            description: "Run 7-gate cross-artifact validation and generate report",
+            category: "validation",
+            depends_on: [...artifactTypes],
+            inputs: [
+                { name: "cwd", type: "path", required: true, description: "Project working directory" }
+            ],
+            outputs: [
+                { name: "validationResult", type: "json", description: "Validation result with pass/fail and issues" }
+            ],
+            tags: ["validation", "consistency"]
+        },
+        async execute(context, inputs) {
+            const cwd = inputs.cwd ?? context.state.cwd;
+            context.progress(1, 2, "Validating artifacts...");
+            const result = await (0, validate_1.runValidate)(cwd, {});
+            context.progress(2, 2, `Validation ${result.pass ? "passed" : "failed"}.`);
+            context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
+            context.state.validationResult = result;
+            return {
+                validationResult: {
+                    pass: result.pass,
+                    reportPath: result.reportPath,
+                    issueCount: result.issues.length
+                }
+            };
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmarasy/prodo",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "CLI-first, prompt-powered product artifact kit",
   "main": "dist/cli/index.js",
   "types": "dist/cli/index.d.ts",
@@ -22,11 +22,9 @@
     "node": ">=20"
   },
   "scripts": {
-    "build:ts": "tsc -p tsconfig.json",
-    "build:i18n": "node -e \"const fs=require('fs');const p=require('path');['en','tr'].forEach(l=>{const s=p.join('src','i18n',l+'.json');const d=p.join('dist','i18n',l+'.json');fs.copyFileSync(s,d)})\"",
-    "build": "npm run build:ts && npm run build:i18n",
-    "test": "npm run build && node --test tests/*.test.cjs",
-    "verify:release": "npm run build && node scripts/verify-release-build.cjs"
+    "build": "node scripts/build.cjs",
+    "test": "node scripts/test.cjs",
+    "verify:release": "node scripts/build.cjs"
   },
   "keywords": [
     "product-management",

package/src/cli/agent-command-installer.ts

@@ -122,7 +122,97 @@ async function loadCommandTemplateNames(commandTemplatesDir: string): Promise<st
     .sort();
 }
 
-export async function installAgentCommands(projectRoot: string, ai: SupportedAi): Promise<string[]> {
+function generateClaudeMd(projectRoot: string, lang: string): string {
+  const projectName = path.basename(projectRoot) || "Product";
+  return `# Prodo — Product Artifact Workspace
+
+This project uses **Prodo** to generate product documentation from a brief.
+
+## Project Structure
+
+- \`brief.md\` — Product brief (INPUT — read-only during generation)
+- \`product-docs/\` — Generated artifacts (OUTPUT)
+- \`.prodo/\` — Internal scaffold (templates, schemas, prompts, state)
+
+## Workflow
+
+Run commands in this sequence:
+
+1. \`/prodo-normalize\` — Parse brief into structured JSON
+2. \`/prodo-prd\` — Generate Product Requirements Document
+3. \`/prodo-workflow\` — Generate workflow diagrams (Markdown + Mermaid)
+4. \`/prodo-wireframe\` — Generate wireframes (Markdown + HTML)
+5. \`/prodo-stories\` — Generate user stories with Gherkin scenarios
+6. \`/prodo-techspec\` — Generate technical specification
+7. \`/prodo-validate\` — Cross-artifact validation (7 gates)
+
+## Rules
+
+- **Never modify \`brief.md\` during command execution** — it is read-only input
+- **All artifacts must include contract tags** like \`[G1]\`, \`[F2]\`, \`[C1]\` for traceability
+- **Output language is \`${lang}\`** — do not mix languages in generated content
+- **Follow templates strictly** — each artifact has a template in \`.prodo/templates/\`
+- **Validate after generation** — run \`/prodo-validate\` to check consistency
+`;
+}
+
+function generateArtifactRules(lang: string): string {
+  return `# Artifact Format Rules
+
+## Contract Tags
+Every artifact must reference brief requirements using tags:
+- \`[G1]\`, \`[G2]\` — Goal references
+- \`[F1]\`, \`[F2]\` — Feature references
+- \`[C1]\`, \`[C2]\` — Constraint references
+
+Tags must appear inline where the requirement is addressed.
+
+## Frontmatter
+Every generated artifact must include YAML frontmatter:
+\`\`\`yaml
+artifact_type: prd | workflow | wireframe | stories | techspec
+version: <timestamp>
+source_brief: <path to normalized-brief.json>
+generated_at: <ISO timestamp>
+status: draft
+contract_coverage:
+  goals: [G1, G2]
+  core_features: [F1, F2]
+  constraints: [C1]
+\`\`\`
+
+## Paired Outputs
+- **Workflow**: Produces \`.md\` (narrative) + \`.mmd\` (Mermaid diagram)
+- **Wireframe**: Produces \`.md\` (description) + \`.html\` (low-fidelity prototype)
+
+## Language
+Output language: **${lang}**. Do not mix languages. Required heading names stay in English.
+`;
+}
+
+function generateBriefRules(): string {
+  return `# Brief Writing Rules
+
+## Structure
+The brief (\`brief.md\`) should contain these sections:
+
+- **Product Name** — Clear, specific product name
+- **Problem** — Core problem the product solves (be specific)
+- **Audience** — Target users (list distinct personas)
+- **Goals** — Measurable objectives (not vague aspirations)
+- **Core Features** — One capability per bullet point
+- **Constraints** — Technical, business, or regulatory limits
+- **Assumptions** — Open questions or working assumptions
+
+## Tips
+- Be specific: "Reduce checkout abandonment by 30%" not "Improve UX"
+- Use consistent terminology throughout
+- Each feature should be distinct and independently describable
+- Constraints should be concrete: "Node.js 20+", "GDPR compliant"
+`;
+}
+
+export async function installAgentCommands(projectRoot: string, ai: SupportedAi, lang?: string): Promise<string[]> {
   const cfg = AGENT_CONFIG[ai];
   const target = path.join(projectRoot, cfg.baseDir);
   const commandTemplatesDir = path.join(projectRoot, ".prodo", "commands");
@@ -130,6 +220,30 @@ export async function installAgentCommands(projectRoot: string, ai: SupportedAi)
   await ensureDir(target);
 
   const written: string[] = [];
+
+  if (ai === "claude-cli") {
+    const claudeMdPath = path.join(projectRoot, "CLAUDE.md");
+    if (!(await fileExists(claudeMdPath))) {
+      await fs.writeFile(claudeMdPath, generateClaudeMd(projectRoot, lang ?? "en"), "utf8");
+      written.push(claudeMdPath);
+    }
+
+    const rulesDir = path.join(projectRoot, ".claude", "rules");
+    await ensureDir(rulesDir);
+
+    const artifactRulesPath = path.join(rulesDir, "artifact-format.md");
+    if (!(await fileExists(artifactRulesPath))) {
+      await fs.writeFile(artifactRulesPath, generateArtifactRules(lang ?? "en"), "utf8");
+      written.push(artifactRulesPath);
+    }
+
+    const briefRulesPath = path.join(rulesDir, "brief-rules.md");
+    if (!(await fileExists(briefRulesPath))) {
+      await fs.writeFile(briefRulesPath, generateBriefRules(), "utf8");
+      written.push(briefRulesPath);
+    }
+  }
+
   for (const commandName of commandNames) {
     const templatePath = path.join(commandTemplatesDir, `${commandName}.md`);
     if (!(await fileExists(templatePath))) {

package/src/cli/doctor.ts

@@ -137,8 +137,8 @@ export async function runDoctor(cwd: string, out: (line: string) => void): Promi
   out("");
   out(renderLogo(width));
   out("");
-  out(center(color("Prodo — Product Artifact Toolkit", "\u001B[1;37m"), width));
-  out(center(color("Crafted by Codex, guided by Shahmarasy intelligence", "\u001B[2;37m"), width));
+  out(center(color("Prodo — AI-Powered Product Owner", "\u001B[1;37m"), width));
+  out(center(color("Built by Shahmarasy · Works with Claude, Codex, and Gemini", "\u001B[2;37m"), width));
   out("");
   out("Checking environment...");
   out("");

package/src/cli/index.ts

@@ -120,7 +120,7 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
 
   program
     .command("init [target]")
-    .option("--ai <name>", "agent integration: codex | gemini-cli | claude-cli")
+    .option("--ai <name>", "agent: codex | gemini-cli | claude-cli")
     .option("--lang <code>", "document language (e.g. en, tr)")
     .option("--author <name>", "document author name")
     .option("--preset <name>", "preset to install during initialization")
@@ -165,15 +165,14 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
       });
       out(`Initialized Prodo scaffold at ${path.join(projectRoot, ".prodo")}`);
       if (selectedAi) {
-        out(`Agent command set installed for ${selectedAi}.`);
+        const label = selectedAi === "claude-cli" ? "Claude Code"
+          : selectedAi === "codex" ? "Codex" : "Gemini CLI";
+        out(`Agent commands installed for ${label}.`);
         out(`Installed ${result.installedAgentFiles.length} command files.`);
-        out("Agent workflow: edit brief.md, then run slash commands in your agent.");
+        out(`Next: edit brief.md, open in ${label}, run /prodo-normalize`);
       } else {
-        out("No agent selected. Use `prodo generate` for end-to-end generation.");
+        out("Next: edit brief.md, then run `prodo generate`.");
       }
-      out(`Settings file: ${result.settingsPath}`);
-      out(`Author: ${selected.author}`);
-      out("Next: edit brief.md.");
     });
 
   program
@@ -196,28 +195,30 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
         return;
       }
       await withBriefReadOnlyGuard(cwd, async () => {
-        await runHookPhase(cwd, "before_normalize", out);
-        const normalizedPath = await runNormalize({ cwd });
-        out(`Normalized brief written to: ${normalizedPath}`);
-        await runHookPhase(cwd, "after_normalize", out);
+        const { createEngine, createPipelineState } = await import("../skill-engine");
+        const engine = await createEngine(cwd, out);
+        const state = createPipelineState(cwd);
+        const pipelineSkills = ["normalize", ...artifactTypes, "validate"];
 
-        for (const type of artifactTypes) {
-          await runArtifactCommand(type, { from: normalizedPath, agent: opts.agent }, cwd, out, {
-            suggestValidate: false
-          });
-        }
+        await runHookPhase(cwd, "before_normalize", out);
 
-        await runHookPhase(cwd, "before_validate", out);
-        const result = await runValidate(cwd, {
-          strict: Boolean(opts.strict),
-          report: opts.report
+        const finalState = await engine.runPipeline(pipelineSkills, state, {
+          log: (msg) => {
+            out(msg);
+          },
+          agent: opts.agent
         });
-        out(`Validation report written to: ${result.reportPath}`);
-        if (!result.pass) {
+
+        await runHookPhase(cwd, "after_validate", out);
+
+        if (finalState.validationResult && !finalState.validationResult.pass) {
+          out(`Validation report written to: ${finalState.validationResult.reportPath}`);
           throw new UserError("Validation failed. Review report and fix issues.");
         }
+        if (finalState.validationResult) {
+          out(`Validation report written to: ${finalState.validationResult.reportPath}`);
+        }
         out("Generation pipeline completed. Validation passed.");
-        await runHookPhase(cwd, "after_validate", out);
       });
     });
 
@@ -388,35 +389,38 @@ export async function runCli(options: RunOptions = {}): Promise<number> {
     });
 
   program
-    .command("skills", { hidden: true })
-    .description("Advanced: manage and run skills")
+    .command("skills")
+    .description("Manage and run skills")
     .argument("[action]", "list or run", "list")
     .argument("[name]", "skill name (for run)")
     .option("--input <json>", "JSON input for skill execution")
     .action(async (action: string, name: string | undefined, opts: { input?: string }) => {
-      const { getGlobalSkillEngine } = await import("../skills/engine");
-      const engine = getGlobalSkillEngine();
+      const { createEngine, createHydratedState } = await import("../skill-engine");
+      const engine = await createEngine(cwd, out);
+      const registry = engine.getRegistry();
 
       if (action === "list") {
-        const manifests = engine.listSkills();
+        const manifests = registry.listManifests();
         if (manifests.length === 0) {
           out("No skills registered.");
           return;
         }
         out("Available skills:\n");
         for (const m of manifests) {
-          out(`  ${m.name.padEnd(25)} [${m.category}] ${m.description}`);
+          const deps = m.depends_on.length > 0 ? ` (deps: ${m.depends_on.join(", ")})` : "";
+          out(`  ${m.name.padEnd(25)} [${m.category}] v${m.version} ${m.description}${deps}`);
         }
         return;
       }
 
       if (action === "run") {
         if (!name) throw new UserError("Skill name is required. Usage: prodo skills run <name>");
+        const state = await createHydratedState(cwd);
         const inputs = opts.input ? JSON.parse(opts.input) as Record<string, unknown> : {};
         inputs.cwd = inputs.cwd ?? cwd;
-        const result = await engine.execute(name, { cwd, log: out }, inputs);
+        const result = await engine.runSkill(name, state, { log: out });
         out(`\nSkill "${name}" completed.`);
-        out(JSON.stringify(result, null, 2));
+        out(`Completed skills: ${result.completedSkills.join(" → ")}`);
         return;
       }