@juancr11/sibu 0.1.0 → 0.3.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,21 @@ 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',
+        },
+    },
+];
 export const SUPPORTED_AGENTS = [
     {
         id: 'codex',
@@ -195,5 +210,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.1.0",
+  "version": "0.3.0",
   "description": "CLI for setting up a local AI-augmented development workflow.",
   "repository": {
     "type": "git",
@@ -27,15 +27,17 @@
     "build": "tsc && chmod +x bin/sibu.js",
     "check": "tsc --noEmit",
     "verify": "pnpm build && pnpm check && pnpm test",
+    "admin:changelog": "node ./bin/admin/changelog.js",
     "dev:link": "pnpm install && pnpm build && pnpm link --global",
     "dev:unlink": "pnpm unlink --global sibu",
     "prepack": "pnpm run build",
     "smoke:init": "node ./bin/sibu.js init",
-    "test": "pnpm build && node --test bin/shared/catalog.test.js bin/shared/npm-version.test.js bin/shared/prompts.test.js bin/shared/workflow-targets.test.js bin/shared/workflow-mutation-readiness.test.js bin/features/doctor-project/handler.test.js bin/features/use-skill/handler.test.js bin/features/stop-managing-file/handler.test.js",
+    "test": "pnpm build && node --test bin/shared/catalog.test.js bin/shared/npm-version.test.js bin/shared/prompts.test.js bin/shared/workflow-targets.test.js bin/shared/workflow-mutation-readiness.test.js bin/admin/generate-changelog/handler.test.js bin/admin/release.test.js bin/admin/release-workflow/handler.test.js bin/admin/release-workflow/package-json.test.js bin/features/doctor-project/handler.test.js bin/features/use-skill/handler.test.js bin/features/stop-managing-file/handler.test.js",
     "validate:packed-runtime": "node ./scripts/validate-packed-cli-runtime.mjs",
     "validate:doctor-version-advisory": "pnpm build && node ./scripts/validate-doctor-version-advisory.mjs",
     "validate:post-update-doctor-drift": "pnpm build && node ./scripts/validate-post-update-doctor-drift.mjs",
-    "validate:release": "pnpm verify && npm pack && pnpm run validate:packed-runtime && pnpm run validate:doctor-version-advisory && pnpm run validate:post-update-doctor-drift"
+    "validate:release": "pnpm verify && npm pack && pnpm run validate:packed-runtime && pnpm run validate:doctor-version-advisory && pnpm run validate:post-update-doctor-drift",
+    "admin:release": "node ./bin/admin/release.js"
   },
   "keywords": [
     "ai",

package/templates/AGENTS.md

@@ -13,7 +13,8 @@
 
 ## Agent-specific instructions
 
-- Before any task that requires code changes, propose a brief plan and wait for user confirmation once per requested task.
+- Before any task that writes or modifies code, propose a brief plan and wait for user confirmation once per requested task.
+- For read-only work, research, planning, documentation-only edits, or other non-code changes, do not ask for confirmation unless the action is destructive, risky, ambiguous, or explicitly requires user approval.
 - After confirmation, proceed with all agreed in-scope changes without re-asking.
 - Ask again only if the scope changes materially, the approach becomes materially more complex or risky, or the user explicitly asks to review before continuing.
 - Use Conventional Commits 1.0.0 for commit messages.
@@ -33,7 +34,7 @@
 - For requests to create, revise, or clarify a technical design, implementation-oriented design doc, architecture approach, technical tradeoffs, technical risks, or implementation plan for an approved feature, use `technical-design-writer`.
 - For requests to create Epics, User Stories, Scrum planning artifacts, backlog slices, or delivery plans from an approved feature brief and technical design, use `scrum-master-planner`.
 - For requests to turn a specific User Story into an implementation checklist, coding plan, step-by-step execution plan, or baby-step plan, use `ai-implementation-planner`.
-- For requests to implement, execute, continue, or work through an existing story implementation plan under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.impl_plan/`, use `ai-implementation-plan-executor`.
+- For requests to implement, execute, continue, or work through a specific User Story under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.md` or an existing story implementation plan under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.impl_plan/`, use `ai-implementation-plan-executor`; the executor must stop and direct the user to `ai-implementation-planner` when the story plan is missing.
 {{OPTIONAL_SKILL_ROUTING}}
 
 ## Sibu maintenance

package/templates/manifest.json

@@ -1,11 +1,12 @@
 {
-  "templateVersion": "42",
+  "templateVersion": "46",
   "templates": {
     "AGENTS.md": {
-      "version": "18",
+      "version": "20",
       "description": "Project-level agent instructions and Sibu maintenance guidance.",
       "changes": [
-        "Renames the workflow maintenance commands and state path from Echo to Sibu so generated guidance matches the new product name."
+        "Routes User Story implementation requests to the AI implementation plan executor, even when the story plan may still be missing.",
+        "Clarifies that the executor should direct users to the AI implementation planner when a User Story has no implementation plan."
       ]
     },
     ".codex/config.toml": {
@@ -70,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": {
@@ -118,11 +119,19 @@
       ]
     },
     "skills/ai-implementation-plan-executor/SKILL.md": {
-      "version": "3",
+      "version": "5",
       "description": "Mandatory AI implementation plan executor skill for implementing existing story implementation plans one reviewed step at a time.",
       "changes": [
-        "Changes implementation plan executor review status to record the current Git user in the Approved by field.",
-        "Keeps the approved-step commit gate before moving to the next implementation step."
+        "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."
+      ]
+    },
+    "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."
       ]
     }
   }

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

@@ -48,11 +48,18 @@ Inspect existing code, tests, scripts, and docs only as needed for the current s
 
 ## Hard start rule
 
-If the `.impl_plan/` folder does not exist, is empty, or has no ordered `.md` step files:
+If the user provides a User Story file and the matching `.impl_plan/` folder does not exist, is empty, or has no ordered `.md` step files:
 
 1. Stop.
 2. Tell the user the implementation plan is missing.
-3. Instruct the user to use `ai-implementation-planner` to create the implementation plan first.
+3. Instruct the user to use `templates/skills/ai-implementation-planner/SKILL.md` to create the implementation plan first.
+4. Do not infer steps from the story or technical design.
+
+If the user provides an `.impl_plan/` folder and it does not exist, is empty, or has no ordered `.md` step files:
+
+1. Stop.
+2. Tell the user the implementation plan is missing or invalid.
+3. Instruct the user to use `templates/skills/ai-implementation-planner/SKILL.md` to create or repair the implementation plan first.
 4. Do not infer steps from the story or technical design.
 
 If required source context is missing:
@@ -66,6 +73,8 @@ If required source context is missing:
 
 Work on exactly one step at a time.
 
+When a valid implementation plan exists, begin implementing the first unapproved step immediately. Do not ask for pre-implementation confirmation before changing code for that step. This is an explicit exception to repository-level instructions that normally require confirmation before code changes: selecting this executor skill and providing a valid plan is the user's confirmation to implement the current step.
+
 A step file is considered approved only when it contains this section:
 
 ```md
@@ -78,7 +87,7 @@ When starting or resuming a plan:
 
 1. Read all step files in filename order.
 2. Identify the first step file that is not approved.
-3. Implement only that step.
+3. Implement only that step immediately, without asking for confirmation first.
 4. Run the validation named in that step when practical.
 5. Report what changed, validation results, and any risks.
 6. Stop and wait for explicit user confirmation before moving to the next step.
@@ -103,10 +112,22 @@ When the user explicitly approves the current step, update that step file by add
 
 Before writing the approval marker, identify the current Git user with `git config user.name`; if it is unavailable, use `git config user.email`. Use that value for `Approved by`. After writing the approval marker, commit all changes for the approved step before continuing. Use a Conventional Commits 1.0.0 message that describes the completed step. If the commit fails, stop and report the failure instead of continuing.
 
-Then continue with the next unapproved step only after the approval marker is written and the approved step changes are committed.
+Then continue with the next unapproved step immediately, without asking for another pre-implementation confirmation, only after the approval marker is written and the approved step changes are committed.
 
 If the user asks to continue without clearly approving the current step, ask for explicit approval before marking it approved, committing, or moving on.
 
+## Epic continuation check
+
+When all step files in the current story implementation plan are approved and committed:
+
+1. Inspect the current Epic's `stories/` folder in filename order.
+2. Identify whether there is a next User Story after the completed story.
+3. If a next User Story exists and its `.impl_plan/` folder exists with ordered step files, ask the user whether they want to implement that next story.
+4. If a next User Story exists but its `.impl_plan/` folder is missing or empty, ask the user whether they want to plan that next story with `ai-implementation-planner`.
+5. If there is no next User Story in the Epic, tell the user the Epic appears ready.
+
+Do not automatically start planning or implementing the next story. This check is a handoff prompt after the current story is complete, not permission to continue without the user's explicit direction.
+
 ## Implementation rules
 
 Do:
@@ -136,3 +157,9 @@ After implementing one step, briefly report:
 - validation run and result
 - any risks, blockers, or follow-up questions
 - that you are waiting for user approval before marking the step approved, committing it, and continuing to the next step
+
+After approving and committing the final step in a story implementation plan, also briefly report the Epic continuation check result:
+
+- next story ready to implement
+- next story needs an implementation plan
+- or Epic appears ready

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.