@juancr11/sibu 0.2.0 → 0.4.0

package/bin/features/list-skills/handler.js

@@ -1,6 +1,6 @@
 import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
-import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS } from '../../shared/catalog.js';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS } from '../../shared/catalog.js';
 import { getProjectContext } from '../../shared/paths.js';
 import { renderIntro } from '../../shared/prompts.js';
 import { readStateForDoctor } from '../../shared/state.js';
@@ -17,6 +17,7 @@ export async function handleListSkills(_command) {
     logSkillGroup('Languages', getLanguageSkillItems(state));
     logSkillGroup('Frameworks', getFrameworkSkillItems(state));
     logSkillGroup('Architecture', getArchitectureSkillItems(state));
+    logSkillGroup('Workflow', getWorkflowSkillItems(state));
     outro(chalk.green('Skill list ready.'));
 }
 function getLanguageSkillItems(state) {
@@ -45,6 +46,15 @@ function getArchitectureSkillItems(state) {
         selected: state?.selectedArchitectureSkill === skill.id,
     }));
 }
+function getWorkflowSkillItems(state) {
+    const selectedSkillIds = new Set(state?.selectedWorkflowSkills ?? []);
+    return SELECTABLE_WORKFLOW_SKILLS.map((skill) => ({
+        name: skill.name,
+        id: skill.id,
+        description: skill.description,
+        selected: selectedSkillIds.has(skill.id),
+    }));
+}
 function logSkillGroup(label, skills) {
     log.message(chalk.bold(label));
     for (const skill of skills) {

package/bin/features/stop-managing-file/handler.js

@@ -9,7 +9,7 @@ import { renderIntro } from '../../shared/prompts.js';
 import { cloneState, readStateForDoctor, writeStateFile } from '../../shared/state.js';
 import { getTemplateVersion, readTemplateManifest, renderTemplateForSync } from '../../shared/templates.js';
 import { removeUndefinedFields } from '../../shared/object.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, } from '../../shared/workflow-targets.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../shared/workflow-targets.js';
 export async function handleStopManagingFile({ skillName }) {
     await renderIntro();
     intro(chalk.cyan('Updating skill management'));
@@ -109,6 +109,8 @@ function isSkillSelected(state, resolved) {
             return state.selectedFrameworkSkills?.includes(resolved.skill.id) ?? false;
         case 'architecture':
             return state.selectedArchitectureSkill === resolved.skill.id;
+        case 'workflow':
+            return state.selectedWorkflowSkills?.includes(resolved.skill.id) ?? false;
     }
 }
 function removeSelectedSkill(state, resolved) {
@@ -122,6 +124,9 @@ function removeSelectedSkill(state, resolved) {
         case 'architecture':
             delete state.selectedArchitectureSkill;
             return;
+        case 'workflow':
+            state.selectedWorkflowSkills = (state.selectedWorkflowSkills ?? []).filter((skillId) => skillId !== resolved.skill.id);
+            return;
     }
 }
 function getSkillManagedPaths(rootPath, state, resolved) {
@@ -161,6 +166,7 @@ function getAgentsUpdate(rootPath, state) {
             selectedLanguageSkills: getSelectedLanguageSkillsFromState(state),
             selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
             selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
+            selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(state),
         }),
     };
 }

package/bin/features/sync-project/apply-action.js

@@ -5,7 +5,7 @@ import { sha256 } from '../../shared/hash.js';
 import { getSideTemplatePath } from '../../shared/paths.js';
 import { cloneState } from '../../shared/state.js';
 import { getTemplateVersion, renderTemplateForSync } from '../../shared/templates.js';
-import { getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState } from '../../shared/workflow-targets.js';
+import { getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../shared/workflow-targets.js';
 export function applySyncAction({ rootPath, state, manifest, preview, action, }) {
     const nextState = cloneState(state);
     const managedFile = nextState.managedFiles[preview.relativePath] ?? preview.managedFile;
@@ -19,6 +19,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
                 selectedLanguageSkills: getSelectedLanguageSkillsFromState(nextState),
                 selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(nextState),
                 selectedArchitectureSkill: getSelectedArchitectureSkillFromState(nextState),
+                selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(nextState),
             });
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
             fs.writeFileSync(targetPath, contents, 'utf8');
@@ -54,6 +55,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
                 selectedLanguageSkills: getSelectedLanguageSkillsFromState(state),
                 selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
                 selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
+                selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(state),
             });
             fs.mkdirSync(path.dirname(sideTemplatePath), { recursive: true });
             fs.writeFileSync(sideTemplatePath, contents, 'utf8');

package/bin/features/use-skill/handler.js

@@ -44,6 +44,7 @@ export function getNextSkillSelection(state, skillName) {
     }
     const selectedLanguageSkills = [...(state.selectedLanguageSkills ?? [])];
     const selectedFrameworkSkills = [...(state.selectedFrameworkSkills ?? [])];
+    const selectedWorkflowSkills = [...(state.selectedWorkflowSkills ?? [])];
     switch (resolution.resolved.kind) {
         case 'language':
             if (selectedLanguageSkills.includes(resolution.resolved.skill.id)) {
@@ -56,6 +57,7 @@ export function getNextSkillSelection(state, skillName) {
                     selectedLanguageSkills: [...selectedLanguageSkills, resolution.resolved.skill.id].map(getLanguageSkillById),
                     selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
                     selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
+                    selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
                 },
             };
         case 'framework':
@@ -69,6 +71,7 @@ export function getNextSkillSelection(state, skillName) {
                     selectedLanguageSkills: selectedLanguageSkills.map(getLanguageSkillById),
                     selectedFrameworkSkills: [...selectedFrameworkSkills, resolution.resolved.skill.id].map(getFrameworkSkillById),
                     selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
+                    selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
                 },
             };
         case 'architecture':
@@ -89,6 +92,21 @@ export function getNextSkillSelection(state, skillName) {
                     selectedLanguageSkills: selectedLanguageSkills.map(getLanguageSkillById),
                     selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
                     selectedArchitectureSkill: resolution.resolved.skill,
+                    selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                },
+            };
+        case 'workflow':
+            if (selectedWorkflowSkills.includes(resolution.resolved.skill.id)) {
+                return { status: 'noop', message: `${resolution.resolved.skill.name} is already selected.` };
+            }
+            return {
+                status: 'selected',
+                skillName: resolution.resolved.skill.name,
+                selection: {
+                    selectedLanguageSkills: selectedLanguageSkills.map(getLanguageSkillById),
+                    selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
+                    selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
+                    selectedWorkflowSkills: [...selectedWorkflowSkills, resolution.resolved.skill.id].map(getWorkflowSkillById),
                 },
             };
     }
@@ -108,6 +126,7 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
     });
     const [newSkillFile] = renderMissingWorkflowFiles({
         missingTargets: [plan.newSkillTarget],
@@ -127,6 +146,7 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
         targets: plan.targets,
     });
     log.success(`Updated ${STATE_RELATIVE_PATH}`);
@@ -134,8 +154,8 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
 }
 function buildSkillApplicationPlan({ rootPath, state, selectionResult, }) {
     const selectedAgents = getSelectedAgentsFromState(state);
-    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill));
-    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill);
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill), getSelectedWorkflowSkillsFromState(state));
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill, selectionResult.selection.selectedWorkflowSkills);
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
     const newSkillTarget = targets.find((target) => !previousTargetPaths.has(target.targetPath));
     const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
@@ -171,6 +191,9 @@ function getSelectedLanguageSkillsFromState(state) {
 function getSelectedFrameworkSkillsFromState(state) {
     return (state.selectedFrameworkSkills ?? []).map(getFrameworkSkillById);
 }
+function getSelectedWorkflowSkillsFromState(state) {
+    return (state.selectedWorkflowSkills ?? []).map(getWorkflowSkillById);
+}
 function getLanguageSkillById(skillId) {
     const resolution = resolveSelectableSkillById(skillId);
     if (!resolution.ok || resolution.resolved.kind !== 'language') {
@@ -195,3 +218,10 @@ function getArchitectureSkillById(skillId) {
     }
     return resolution.resolved.skill;
 }
+function getWorkflowSkillById(skillId) {
+    const resolution = resolveSelectableSkillById(skillId);
+    if (!resolution.ok || resolution.resolved.kind !== 'workflow') {
+        throw new Error(`Unsupported workflow skill in state: ${skillId}`);
+    }
+    return resolution.resolved.skill;
+}

package/bin/shared/catalog.js

@@ -154,6 +154,34 @@ export const SELECTABLE_ARCHITECTURE_SKILLS = [
         },
     },
 ];
+export const SELECTABLE_WORKFLOW_SKILLS = [
+    {
+        id: 'ai-prompt-engineer-master',
+        name: 'AI Prompt Engineer Master',
+        description: 'Install guidance for creating, rewriting, optimizing, compressing, and evaluating AI prompts',
+        routingInstruction: 'For requests to create, rewrite, optimize, compress, evaluate, or systematize prompts for AI models, agents, tools, coding assistants, product workflows, or reusable prompt templates, use `ai-prompt-engineer-master`.',
+        templateRelativePath: 'skills/ai-prompt-engineer-master/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/ai-prompt-engineer-master/SKILL.md',
+            gemini: '.agents/skills/ai-prompt-engineer-master/SKILL.md',
+            claude: '.agents/skills/ai-prompt-engineer-master/SKILL.md',
+            windsurf: '.agents/skills/ai-prompt-engineer-master/SKILL.md',
+        },
+    },
+    {
+        id: 'ux-expert',
+        name: 'UX Expert',
+        description: 'Install senior UX/UI guidance for UI-changing features, responsive layouts, flows, states, accessibility, and binding mockups',
+        routingInstruction: 'For UX/UI design after product definition when a feature has UI changes, use `ux-expert`; downstream technical design, Scrum planning, implementation planning, and implementation must treat mockups in `docs/features/<feature-slug>/ux.md` as binding UI goals, not redesign targets.',
+        templateRelativePath: 'skills/ux-expert/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/ux-expert/SKILL.md',
+            gemini: '.agents/skills/ux-expert/SKILL.md',
+            claude: '.agents/skills/ux-expert/SKILL.md',
+            windsurf: '.agents/skills/ux-expert/SKILL.md',
+        },
+    },
+];
 export const SUPPORTED_AGENTS = [
     {
         id: 'codex',
@@ -195,5 +223,9 @@ export function resolveSelectableSkillById(skillId) {
     if (architectureSkill) {
         return { ok: true, resolved: { kind: 'architecture', skill: architectureSkill } };
     }
+    const workflowSkill = SELECTABLE_WORKFLOW_SKILLS.find((skill) => skill.id === skillId);
+    if (workflowSkill) {
+        return { ok: true, resolved: { kind: 'workflow', skill: workflowSkill } };
+    }
     return { ok: false, message: `Unknown skill \`${skillId}\`. Run \`sibu skills list\` to see available skills.` };
 }

package/bin/shared/state.js

@@ -55,6 +55,8 @@ function isSibuState(value) {
         (state.selectedFrameworkSkills === undefined ||
             (Array.isArray(state.selectedFrameworkSkills) && state.selectedFrameworkSkills.every((skill) => typeof skill === 'string'))) &&
         (state.selectedArchitectureSkill === undefined || typeof state.selectedArchitectureSkill === 'string') &&
+        (state.selectedWorkflowSkills === undefined ||
+            (Array.isArray(state.selectedWorkflowSkills) && state.selectedWorkflowSkills.every((skill) => typeof skill === 'string'))) &&
         (state.reviewedArchitectureSkills === undefined ||
             (Array.isArray(state.reviewedArchitectureSkills) && state.reviewedArchitectureSkills.every((skill) => typeof skill === 'string'))) &&
         !!state.managedFiles &&

package/bin/shared/sync-preview.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { sha256 } from './hash.js';
 import { hasReviewedTemplateVersion } from './state.js';
 import { renderTemplateForSync } from './templates.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getWorkflowTargets, } from './workflow-targets.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from './workflow-targets.js';
 const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
     'new-template',
     'missing',
@@ -29,6 +29,7 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     const selectedLanguageSkills = getSelectedLanguageSkillsFromState(state);
     const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
     const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
+    const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
     const previews = Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
         rootPath,
         manifest,
@@ -37,8 +38,9 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
+        selectedWorkflowSkills,
     }));
-    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
     for (const target of expectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
         if (state.managedFiles[relativePath]) {
@@ -75,7 +77,7 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     }
     return previews;
 }
-function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, }) {
     if (managedFile.status === 'unmanaged') {
         return { relativePath, managedFile, status: 'unmanaged', recordedTemplateVersion: managedFile.templateVersion, changes: [] };
     }
@@ -94,6 +96,7 @@ function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFi
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
+        selectedWorkflowSkills,
     });
     const hasUpdate = hasTemplateUpdate || hasSelectionUpdate;
     const changes = hasTemplateUpdate ? template.changes : ['Refreshes generated skill routing for the current selected skills.'];
@@ -151,7 +154,7 @@ function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFi
         hasLocalFile,
     };
 }
-function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, }) {
     if (relativePath !== 'AGENTS.md') {
         return false;
     }
@@ -161,6 +164,7 @@ function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, se
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
+        selectedWorkflowSkills,
     });
     return sha256(renderedContents) !== managedFile.sha256;
 }

package/bin/shared/templates.js

@@ -18,18 +18,18 @@ export function getTemplateVersion(manifest, templateRelativePath) {
     }
     return template.version;
 }
-export function renderTemplateForSync({ templateRelativePath, currentPath, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+export function renderTemplateForSync({ templateRelativePath, currentPath, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
     let contents = readTemplate(templateRelativePath);
     if (contents.includes('{{PROJECT_OVERVIEW}}')) {
         contents = contents.replace('{{PROJECT_OVERVIEW}}', extractProjectOverview(currentPath) ?? 'Describe this project.');
     }
-    return renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+    return renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
 }
-export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill) {
+export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
     if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
         return contents;
     }
-    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : [])]
+    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []), ...selectedWorkflowSkills]
         .map((skill) => `- ${skill.routingInstruction}`)
         .join('\n');
     return contents.replace('{{OPTIONAL_SKILL_ROUTING}}', optionalRouting);

package/bin/shared/workflow-targets.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { SIBU_VERSION, MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SUPPORTED_AGENTS } from './catalog.js';
+import { SIBU_VERSION, MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from './catalog.js';
 import { sha256 } from './hash.js';
 import { removeUndefinedFields } from './object.js';
 import { readExistingState } from './state.js';
@@ -14,13 +14,17 @@ export function getSelectedFrameworkSkillsFromState(state) {
 export function getSelectedArchitectureSkillFromState(state) {
     return SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === state.selectedArchitectureSkill);
 }
-export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill) {
+export function getSelectedWorkflowSkillsFromState(state) {
+    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => state.selectedWorkflowSkills?.includes(skill.id));
+}
+export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
     const skillTargets = new Map();
     const selectedSkills = [
         ...MANDATORY_SKILLS,
         ...selectedLanguageSkills,
         ...selectedFrameworkSkills,
         ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
+        ...selectedWorkflowSkills,
     ];
     for (const agent of selectedAgents) {
         for (const skill of selectedSkills) {
@@ -36,7 +40,7 @@ export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguag
     }
     return [...skillTargets.values()];
 }
-export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill) {
+export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = []) {
     return [
         {
             label: 'AGENTS.md',
@@ -57,7 +61,7 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
                 },
             ];
         }),
-        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill).map((skillTarget) => ({
+        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills).map((skillTarget) => ({
             label: skillTarget.targetRelativePath,
             targetPath: path.join(rootPath, skillTarget.targetRelativePath),
             templateRelativePath: skillTarget.templateRelativePath,
@@ -65,7 +69,7 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
         })),
     ];
 }
-export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
     return missingTargets.map((target) => {
         let contents = readTemplate(target.templateRelativePath);
         if (target.requiresProjectOverview) {
@@ -74,7 +78,7 @@ export function renderMissingWorkflowFiles({ missingTargets, overview, selectedL
             }
             contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
         }
-        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
         return {
             label: target.label,
             targetPath: target.targetPath,
@@ -82,7 +86,7 @@ export function renderMissingWorkflowFiles({ missingTargets, overview, selectedL
         };
     });
 }
-export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, targets, }) {
+export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], targets, }) {
     const previousState = readExistingState(statePath);
     const now = new Date().toISOString();
     const manifest = readTemplateManifest();
@@ -95,6 +99,7 @@ export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLa
         selectedLanguageSkills: selectedLanguageSkills.map((skill) => skill.id),
         selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
         selectedArchitectureSkill: selectedArchitectureSkill?.id,
+        selectedWorkflowSkills: selectedWorkflowSkills.map((skill) => skill.id),
         managedFiles: Object.fromEntries(targets
             .filter((target) => fs.existsSync(target.targetPath))
             .map((target) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juancr11/sibu",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "CLI for setting up a local AI-augmented development workflow.",
   "repository": {
     "type": "git",

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "templateVersion": "45",
+  "templateVersion": "47",
   "templates": {
     "AGENTS.md": {
       "version": "20",
@@ -54,10 +54,10 @@
       ]
     },
     "skills/technical-design-writer/SKILL.md": {
-      "version": "8",
+      "version": "9",
       "description": "Mandatory technical design writer skill installed once at the shared .agents/skills workspace path.",
       "changes": [
-        "Updates the technical design examples to refer to the Sibu command names instead of the old Echo branding."
+        "Requires UI-related technical designs to read ux.md and treat UX mockups as binding implementation goals instead of redesign targets."
       ]
     },
     "skills/typescript/SKILL.md": {
@@ -71,7 +71,7 @@
       "version": "1",
       "description": "Selectable Go skill installed when Go language support is selected.",
       "changes": [
-        "Adds an optional Go skill with concise, Effective Go–style guidance for .go files, package APIs, interfaces, errors, receivers, concurrency, and tests."
+        "Adds an optional Go skill with concise, Effective Go\u2013style guidance for .go files, package APIs, interfaces, errors, receivers, concurrency, and tests."
       ]
     },
     "skills/architecture/ddd-hexagonal/SKILL.md": {
@@ -103,28 +103,38 @@
       ]
     },
     "skills/scrum-master-planner/SKILL.md": {
-      "version": "2",
+      "version": "3",
       "description": "Mandatory Scrum planner skill for creating pragmatic Epics and User Stories from approved feature and technical design docs.",
       "changes": [
-        "Moves Scrum User Stories into an Epic-local stories/ folder.",
-        "Adds two-digit execution-order filename prefixes for User Stories, with shared numbers indicating parallelizable work."
+        "Requires UI-related Scrum planning to read ux.md and preserve binding mockups in Epics and User Stories."
       ]
     },
     "skills/ai-implementation-planner/SKILL.md": {
-      "version": "4",
+      "version": "5",
       "description": "Mandatory AI implementation planner skill for turning one approved User Story into small, story-local implementation step files.",
       "changes": [
-        "Changes AI implementation planner step files to use lowercase .md extensions.",
-        "Updates the step-file format to use Markdown headings for Step, Goal, Scope, Files, and Done when sections."
+        "Requires UI-related implementation plans to read ux.md and turn binding mockups into implementation steps without redesigning them."
       ]
     },
     "skills/ai-implementation-plan-executor/SKILL.md": {
-      "version": "5",
+      "version": "6",
       "description": "Mandatory AI implementation plan executor skill for implementing existing story implementation plans one reviewed step at a time.",
       "changes": [
-        "Clarifies that missing story implementation plans must be created with the AI implementation planner before execution.",
-        "Allows agents to begin the first unapproved implementation step immediately when a valid plan exists, while preserving review approval between steps.",
-        "Clarifies that after user approval, agents should mark the step approved, commit it, and continue to the next step without another pre-implementation confirmation."
+        "Requires UI-related implementation execution to read ux.md and implement binding mockups without redesigning them."
+      ]
+    },
+    "skills/ai-prompt-engineer-master/SKILL.md": {
+      "version": "1",
+      "description": "Selectable AI prompt engineering skill for prompt creation, optimization, compression, and evaluation.",
+      "changes": [
+        "Adds an optional AI prompt engineering skill for projects that create, improve, evaluate, or maintain reusable prompts for AI models, agents, tools, and coding assistants."
+      ]
+    },
+    "skills/ux-expert/SKILL.md": {
+      "version": "1",
+      "description": "Selectable UX expert skill for UI-changing features, responsive design, flows, states, accessibility, and binding mockups.",
+      "changes": [
+        "Adds an optional UX expert skill for UI-changing features, including implementation-ready UX guidance and binding mockups."
       ]
     }
   }

package/templates/skills/ai-implementation-plan-executor/SKILL.md

@@ -33,10 +33,15 @@ docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.impl
 docs/features/<feature-slug>/epics/<epic-slug>/epic_brief.md
 docs/features/<feature-slug>/feature_brief.md
 docs/features/<feature-slug>/technical_design.md
+docs/features/<feature-slug>/ux.md  # when the story, step, or feature has UI impact
 ```
 
 Also read `docs/product-vision.md` when product fit, target user, scope boundaries, or success signals are ambiguous.
 
+If the story, current step, or feature has UI impact and `docs/features/<feature-slug>/ux.md` is missing, stop and ask the user to create the UX spec with `ux-expert` before implementation.
+
+When `ux.md` includes mockups, treat them as binding UI goals. Implementation must preserve the mockup structure, hierarchy, visible content, dominant interactions, major visual emphasis, and breakpoint-specific layout. Do not redesign the UI during execution; implement the approved UX and stop if technical constraints require a UX revision.
+
 Before changing code, read and apply the implementation skills required by the plan and repository routing:
 
 - always read and apply `clean-code`

package/templates/skills/ai-implementation-planner/SKILL.md

@@ -30,10 +30,15 @@ docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.md
 docs/features/<feature-slug>/epics/<epic-slug>/epic_brief.md
 docs/features/<feature-slug>/feature_brief.md
 docs/features/<feature-slug>/technical_design.md
+docs/features/<feature-slug>/ux.md  # when the story or feature has UI impact
 ```
 
 Also read `docs/product-vision.md` when product fit, target user, scope boundaries, or success signals are ambiguous.
 
+If the story or feature has UI impact and `docs/features/<feature-slug>/ux.md` is missing, stop and ask the user to create the UX spec with `ux-expert` before implementation planning.
+
+When `ux.md` includes mockups, treat them as binding UI goals. Implementation steps must preserve the mockup structure, hierarchy, visible content, dominant interactions, major visual emphasis, and breakpoint-specific layout. Do not redesign the UI in the implementation plan; plan code steps that implement the approved UX and stop if technical constraints require a UX revision.
+
 Before writing the step files, read and apply the required planning skills as source context:
 
 - always read and apply `clean-code`

package/templates/skills/ai-prompt-engineer-master/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: ai-prompt-engineer-master
+description: "Use when creating, rewriting, optimizing, compressing, evaluating, or systematizing prompts for AI models, agents, tools, coding assistants, product workflows, or reusable prompt templates. Focus on top-quality results with the smallest effective token budget: preserve or improve output quality first, then remove every token that does not contribute to that quality."
+---
+
+# AI Prompt Engineer Master
+
+## Core principle
+
+Optimize for the **smallest prompt that reliably produces the required quality**.
+
+This skill is model-agnostic: adapt wording to the target model when known, but do not assume any specific provider or model family.
+
+Do not trade quality away for fewer tokens. First define the quality bar, then find the leanest prompt that meets it.
+
+## Workflow
+
+1. **Clarify the prompt job**
+   - Identify the target model or agent if known.
+   - Identify the user, task, input context, output format, quality bar, and failure modes.
+   - Ask only when missing information would materially change the prompt.
+
+2. **Define the quality contract**
+   - State the outcome the prompt must achieve.
+   - Include success criteria, required constraints, and non-negotiable safety or compliance rules.
+   - Define what the model should do when context is missing, ambiguous, or contradictory.
+
+3. **Design outcome-first**
+   - Prefer destination over step-by-step process.
+   - Use process instructions only when order, auditability, or tool behavior truly matters.
+   - Put stable instructions before dynamic task/input content.
+
+4. **Compress without quality loss**
+   - Remove duplicated rules, generic advice, filler, motivational language, and obvious model capabilities.
+   - Replace long explanations with precise constraints or decision rules.
+   - Merge overlapping instructions.
+   - Keep examples only when they prevent likely errors or define subtle style/format expectations.
+
+5. **Make the output easy to verify**
+   - Specify the output shape only as tightly as needed.
+   - Prefer schemas, examples, or bullets when they reduce ambiguity.
+   - Include acceptance checks for high-stakes or reusable prompts.
+
+6. **Deliver usable artifacts**
+   - Provide the final prompt in a copy-ready block.
+   - If helpful, include a short note explaining the token-saving choices.
+   - For reusable prompts, separate stable prompt text from runtime variables.
+
+## Prompt quality checklist
+
+A strong prompt usually has:
+
+- **Role or perspective** only when it changes behavior.
+- **Task** stated as a concrete outcome.
+- **Context** limited to information the model needs.
+- **Constraints** that prevent real failures.
+- **Output format** specific enough for the consumer.
+- **Missing-context behavior** so the model does not invent facts.
+- **Tone/style** only when user-facing quality depends on it.
+- **Validation criteria** for important workflows.
+
+## Token discipline rules
+
+Prefer:
+
+- “Return JSON matching this schema” over a prose explanation of each field when a schema is available.
+- “If evidence is missing, say what is missing” over long hallucination warnings.
+- “Use concise bullets” over multiple style paragraphs.
+- One representative example over many near-duplicates.
+- A short decision rule over absolute words like “always” or “never” unless the rule is truly invariant.
+
+Avoid:
+
+- Repeating the same constraint in multiple sections.
+- Explaining why the model should follow ordinary instructions.
+- Adding chain-of-thought requests.
+- Keeping legacy prompt scaffolding because it “might help.”
+- Compressing away domain terms, examples, or constraints that carry real quality value.
+
+## Output pattern
+
+When optimizing a prompt, use this structure unless the user asks otherwise:
+
+```md
+## Final prompt
+
+<prompt>
+
+## Why this is token-efficient
+
+- <1-3 bullets about what was preserved or removed>
+
+## Optional stronger version
+
+<only include if quality risks justify extra tokens>
+```
+
+If the user only wants the prompt, return only the final prompt.

package/templates/skills/scrum-master-planner/SKILL.md

@@ -18,10 +18,15 @@ Before planning, read:
 ```txt
 docs/features/<feature-slug>/feature_brief.md
 docs/features/<feature-slug>/technical_design.md
+docs/features/<feature-slug>/ux.md  # when the feature has UI impact
 ```
 
 Also read `docs/product-vision.md` when it exists and the planning decision depends on product fit, scope boundaries, user value, or success signals.
 
+If the feature has UI impact and `docs/features/<feature-slug>/ux.md` is missing, stop and ask the user to create the UX spec with `ux-expert` before Scrum planning.
+
+When `ux.md` includes mockups, treat them as binding UI goals. Epics and Stories must preserve the mockup structure, hierarchy, visible content, dominant interactions, major visual emphasis, and breakpoint-specific layout. Do not redesign the UI in Scrum planning; create delivery slices that implement the approved UX.
+
 ## Hard start rule
 
 Do not create Epics or User Stories if either the feature brief or technical design is missing.

package/templates/skills/technical-design-writer/SKILL.md

@@ -15,9 +15,10 @@ Before writing, read:
 
 1. `docs/product-vision.md`
 2. the feature brief
-3. `clean-code`
-4. any selected architecture, language, or framework skills that apply
-5. relevant existing repo files and flows
+3. `docs/features/<feature-slug>/ux.md` when the feature has UI impact
+4. `clean-code`
+5. any selected architecture, language, or framework skills that apply
+6. relevant existing repo files and flows
 
 Apply those inputs. Do not summarize them back into the technical design unless a specific implication changes the implementation.
 
@@ -25,7 +26,11 @@ Apply those inputs. Do not summarize them back into the technical design unless
 
 Require a Markdown feature brief. If the user only has a vague idea, route to `feature-brief-writer` first.
 
-If the feature has UI impact, use an existing UX artifact when available. If missing, note the UI uncertainty briefly instead of inventing UX.
+If the feature has UI impact, require `docs/features/<feature-slug>/ux.md`. If it is missing, stop and ask the user to create the UX spec with `ux-expert` first.
+
+## UX binding rule
+
+For UI-related features, `ux.md` is source context, not inspiration. If `ux.md` includes mockups, treat those mockups as binding UI goals for structure, hierarchy, visible content, dominant interactions, major visual emphasis, and breakpoint-specific layout. Do not redesign the mockups in the technical design. Translate them into implementation direction and call out only technical feasibility issues, missing states, or conflicts that require UX revision.
 
 ## Design stance
 

package/templates/skills/ux-expert/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: ux-expert
+description: Use this skill for UX/UI design after product definition when a feature has UI changes. Requires an approved Markdown product artifact (feature brief) that defines goals, scope, and acceptance criteria; if none exists, route to feature-brief-writer (and product-vision-writer if missing). Use for senior UX/UI direction, phone-first responsive design, breakpoint-specific layouts/components, user flows, information architecture, wireframes, concrete mockups, interaction states, accessibility, visual direction, creative UI concepts, and implementation-ready UI guidance.
+---
+
+# ux-expert
+
+Act as a senior UX/UI designer. Turn an approved product artifact into usable, expressive, phone-first, implementation-ready UI direction. Do not include code, file paths, architecture, or framework-specific guidance.
+
+## Required grounding
+
+Read `docs/product-vision.md` and apply only relevant implications: target user, principles, voice, boundaries, trust expectations, success signal. Do not restate the full vision.
+
+Require a product artifact such as `docs/features/<feature-slug>/feature_brief.md` that defines goal, scope, and acceptance criteria. If the user has only an idea, route to `feature-brief-writer` first. If the artifact says there is no UI impact, say so and do not invent UI work.
+
+## Mockup authority rule
+
+For UI-changing features, the UX artifact must include concrete mockups for affected screens, states, and breakpoints. Mockups are the source of truth for structure, hierarchy, visible content, dominant interactions, and major visual emphasis. Downstream technical design, stories, implementation plans, and implementation must follow them unless this UX spec is explicitly revised.
+
+If a materially affected state/breakpoint lacks a mockup, UX work is incomplete.
+
+## Confirmation behavior
+
+Creating/updating the Markdown UX artifact is not a code change. Write it without pre-change confirmation when the target is clear and requested. Ask only when context is missing, the target is ambiguous, overwrite/destruction is possible, or code changes are required.
+
+## UX principles
+
+Design for user experience first, component reuse second. Prefer clear task completion, strong hierarchy, obvious affordances/feedback/recovery, progressive disclosure, accessibility, resilient states, and distinctive but shippable UI. Avoid generic SaaS/page-builder layouts, decorative clarity loss, desktop-first thinking, product scope changes, and technical architecture decisions.
+
+## Phone-first responsive rule
+
+Design phone first, then re-evaluate tablet and desktop as separate UX problems. Choose different layouts/components across breakpoints when that improves hierarchy, interaction, density, touch/pointer behavior, or content priority. Share components only when they remain the best experience.
+
+## Workflow
+
+1. Read product vision and feature brief.
+2. Identify affected UI surfaces and whether UI work is valid.
+3. Design phone-first flow, information architecture, and layout.
+4. Re-evaluate tablet and desktop independently.
+5. Define interaction states, failure/recovery behavior, accessibility requirements, and creative direction.
+6. Create concrete mockups for primary screens, affected breakpoints, and critical states.
+7. Write implementation-ready UX guidance only: flows, hierarchy, states, accessibility, visual direction.
+
+## Output location
+
+Write to `docs/features/<feature-slug>/ux.md` using the feature artifact slug. Keep same-feature artifacts together; do not write UX specs in product, technical design, story, or implementation-plan files.
+
+## Mockup requirements
+
+Mockups may be low fidelity but must be concrete and unambiguous: layout regions, visible content, hierarchy/emphasis, key controls, major state differences, and breakpoint changes. Use annotated text/box wireframes when enough. Show decisions that downstream implementation must not improvise.
+
+## Output format
+
+Use only helpful sections from this shape:
+
+```md
+# UX Spec: <Feature Name>
+
+## Input Product Artifact
+## Product Vision Implications
+## UX Intent
+## Affected Surfaces
+## Phone-First User Flow
+## Information Architecture
+## Phone Layout
+## Tablet Layout
+## Desktop Layout
+## Binding Mockups
+### Phone
+```text
+<Annotated phone mockup>
+```
+
+### Tablet
+```text
+<Annotated tablet mockup>
+```
+
+### Desktop
+```text
+<Annotated desktop mockup>
+```
+## Breakpoint-Specific Component Strategy
+## Interaction States
+## Accessibility Requirements
+## Visual Direction
+## Creative Opportunities
+## Implementation Notes
+## UI Authority Rule
+## Open UX Questions
+```
+
+The Binding Mockups section is authoritative for downstream work unless this UX spec is revised.