@juancr11/sibu 0.13.2 → 0.14.0

package/bin/modules/interactive-guidance/index.js

@@ -1 +1 @@
-export { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForMcpServers, askForNotionDocsParentPage, askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, MCP_SERVER_SELECTION_MESSAGE, renderIntro, shouldAskForNewLanguageSkills, } from './prompts.js';
+export { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForMcpServers, askForNotionDocsParentPage, askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, MCP_SERVER_SELECTION_MESSAGE, getPromptableWorkflowSkills, renderIntro, shouldAskForNewLanguageSkills, } from './prompts.js';

package/bin/modules/interactive-guidance/prompts.js

@@ -148,11 +148,16 @@ export async function askForArchitectureSkill() {
     }
     return SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === selectedArchitectureSkillId);
 }
-export async function askForWorkflowSkills() {
+export function getPromptableWorkflowSkills(excludedWorkflowSkillIds = []) {
+    const excludedIds = new Set(excludedWorkflowSkillIds);
+    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => !excludedIds.has(skill.id));
+}
+export async function askForWorkflowSkills(excludedWorkflowSkillIds = []) {
+    const promptableWorkflowSkills = getPromptableWorkflowSkills(excludedWorkflowSkillIds);
     const selectedWorkflowSkillIds = await multiselect({
         message: 'Select optional workflow skills for this project.',
         required: false,
-        options: SELECTABLE_WORKFLOW_SKILLS.map((skill) => ({
+        options: promptableWorkflowSkills.map((skill) => ({
             value: skill.id,
             label: skill.name,
             hint: skill.description,
@@ -162,7 +167,7 @@ export async function askForWorkflowSkills() {
         cancel('Initialization cancelled.');
         process.exit(0);
     }
-    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => selectedWorkflowSkillIds.includes(skill.id));
+    return promptableWorkflowSkills.filter((skill) => selectedWorkflowSkillIds.includes(skill.id));
 }
 export function shouldAskForNewLanguageSkills(state) {
     return (state.selectedLanguageSkills?.length ?? 0) === 0;

package/bin/modules/mcp-server-selection-management/use-mcp-server/handler.js

@@ -2,10 +2,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { log } from '@clack/prompts';
 import { STATE_RELATIVE_PATH } from '../../../shared/catalog.js';
+import { sha256 } from '../../../shared/hash.js';
 import { getProjectContext } from '../../../shared/paths.js';
 import { askForNotionDocsParentPage } from '../../interactive-guidance/index.js';
+import { renderTemplateForSync } from '../../template-catalog-rendering/index.js';
 import { getWorkflowMutationReadiness } from '../../workflow-mutation-readiness/index.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, renderMissingWorkflowFiles, resolveSelectableMcpServerById, writeSibuState, } from '../../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles, resolveSelectableMcpServerById, writeSibuState, } from '../../workflow-target-planning/index.js';
 const defaultDependencies = {
     askForNotionDocsParentPage,
 };
@@ -71,11 +73,13 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
     const selectedLanguageSkills = getSelectedLanguageSkillsFromState(state);
     const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
     const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
-    const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const currentWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectionResult.selectedMcpServers.map((server) => server.id));
+    const selectedWorkflowSkills = mergeWorkflowSkills(currentWorkflowSkills, impliedWorkflowSkills);
     const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
-    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, getSelectedMcpServersFromState(state));
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, currentWorkflowSkills, selectedDatabaseSkills, getSelectedMcpServersFromState(state));
     const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectionResult.selectedMcpServers);
-    const affectedTargets = getAffectedMcpTargets(previousTargets, targets);
+    const affectedTargets = getAffectedTargets(previousTargets, targets);
     const preflightError = getMcpUsePreflightError({ rootPath, state, affectedTargets, previousTargets });
     if (preflightError) {
         log.error(preflightError);
@@ -83,8 +87,13 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
         process.exitCode = 1;
         return;
     }
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    if (!agentsTarget) {
+        throw new Error('AGENTS.md target is missing from workflow targets.');
+    }
+    const nonAgentTargets = affectedTargets.filter((target) => target.label !== 'AGENTS.md');
     const files = renderMissingWorkflowFiles({
-        missingTargets: affectedTargets,
+        missingTargets: nonAgentTargets,
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
@@ -95,9 +104,23 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
     for (const file of files) {
         const fileAlreadyExists = fs.existsSync(file.targetPath);
         fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
-        fs.writeFileSync(file.targetPath, file.contents, 'utf8');
+        fs.writeFileSync(file.targetPath, file.contents, fileAlreadyExists ? 'utf8' : { encoding: 'utf8', flag: 'wx' });
         log.success(`${fileAlreadyExists ? 'Updated' : 'Created'} ${file.label}`);
     }
+    if (affectedTargets.some((target) => target.label === 'AGENTS.md')) {
+        const agentsContents = renderTemplateForSync({
+            templateRelativePath: agentsTarget.templateRelativePath,
+            currentPath: agentsTarget.targetPath,
+            selectedLanguageSkills,
+            selectedFrameworkSkills,
+            selectedArchitectureSkill,
+            selectedWorkflowSkills,
+            selectedDatabaseSkills,
+            selectedMcpServers: selectionResult.selectedMcpServers,
+        });
+        fs.writeFileSync(agentsTarget.targetPath, agentsContents, 'utf8');
+        log.success('Updated AGENTS.md skill routing');
+    }
     writeSibuState({
         rootPath,
         statePath,
@@ -113,20 +136,45 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
     });
     log.success(`Updated ${STATE_RELATIVE_PATH}`);
     log.success(`Added ${selectionResult.serverName}.`);
+    for (const skill of impliedWorkflowSkills.filter((skill) => !currentWorkflowSkills.some((currentSkill) => currentSkill.id === skill.id))) {
+        log.success(`Added ${skill.name}.`);
+    }
     log.info('Sibu configured MCP files only; prerequisites, credentials, and provider authentication remain user-owned.');
 }
-function getAffectedMcpTargets(previousTargets, targets) {
+function getAffectedTargets(previousTargets, targets) {
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
-    return targets.filter((target) => target.mcpConfigAgentId || (!previousTargetPaths.has(target.targetPath) && target.targetKind === 'mcp-config'));
+    const newTargets = targets.filter((target) => !previousTargetPaths.has(target.targetPath) && (target.targetKind === 'skill' || target.targetKind === 'mcp-config'));
+    const mcpConfigTargets = targets.filter((target) => target.mcpConfigAgentId);
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    const affectedTargets = new Map();
+    for (const target of [...mcpConfigTargets, ...newTargets, ...(newTargets.some((target) => target.targetKind === 'skill') && agentsTarget ? [agentsTarget] : [])]) {
+        affectedTargets.set(target.targetPath, target);
+    }
+    return [...affectedTargets.values()];
+}
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
 }
 function getMcpUsePreflightError({ rootPath, state, affectedTargets, previousTargets, }) {
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
     for (const target of affectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
         if (previousTargetPaths.has(target.targetPath)) {
-            if (!state.managedFiles[relativePath]) {
+            const managedFile = state.managedFiles[relativePath];
+            if (!managedFile) {
                 return `${relativePath} is not recorded in ${STATE_RELATIVE_PATH}.`;
             }
+            if (!fs.existsSync(target.targetPath)) {
+                return `${relativePath} is missing.`;
+            }
+            const currentHash = sha256(fs.readFileSync(target.targetPath, 'utf8'));
+            if (currentHash !== managedFile.sha256) {
+                return `${relativePath} has changed since Sibu last recorded it.`;
+            }
             continue;
         }
         if (fs.existsSync(target.targetPath)) {

package/bin/modules/project-adoption/handler.js

@@ -6,7 +6,14 @@ import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
 import { getProjectContext } from '../../shared/paths.js';
 import { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForMcpServers, askForNotionDocsParentPage, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro, } from '../interactive-guidance/index.js';
 import { readStateForDoctor } from '../workflow-state-registry/index.js';
-import { getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
+import { getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
+}
 const defaultDependencies = {
     renderIntro,
     askForSupportedAgents,
@@ -41,12 +48,16 @@ export async function handleInitProject(_command, dependencies = defaultDependen
     }
     const selectedAgents = await dependencies.askForSupportedAgents();
     const selectedMcpServers = await dependencies.askForMcpServers();
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectedMcpServers.map((server) => server.id));
+    for (const skill of impliedWorkflowSkills) {
+        log.info(`${skill.name} will be included because its matching MCP server was selected.`);
+    }
     const notionDocsParentPage = selectedMcpServers.some((server) => server.id === 'notion') ? await dependencies.askForNotionDocsParentPage() : undefined;
     const selectedLanguageSkills = await dependencies.askForLanguageSkills();
     const selectedFrameworkSkills = await dependencies.askForFrameworkSkills();
     const selectedDatabaseSkills = await dependencies.askForDatabaseSkills();
     const selectedArchitectureSkill = await dependencies.askForArchitectureSkill();
-    const selectedWorkflowSkills = await dependencies.askForWorkflowSkills();
+    const selectedWorkflowSkills = mergeWorkflowSkills(impliedWorkflowSkills, await dependencies.askForWorkflowSkills(impliedWorkflowSkills.map((skill) => skill.id)));
     const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
     const missingTargets = targets.filter((target) => !fs.existsSync(target.targetPath));
     log.message('I will create this project’s initial AI workflow files.');

package/bin/modules/skill-selection-management/use-skill/handler.js

@@ -2,13 +2,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { log } from '@clack/prompts';
 import { STATE_RELATIVE_PATH } from '../../../shared/catalog.js';
-import { resolveSelectableSkillById } from '../../workflow-target-planning/index.js';
+import { askForNotionDocsParentPage } from '../../interactive-guidance/index.js';
+import { getMcpServersRequiredByWorkflowSkills, resolveSelectableSkillById } from '../../workflow-target-planning/index.js';
 import { sha256 } from '../../../shared/hash.js';
 import { getProjectContext } from '../../../shared/paths.js';
 import { renderTemplateForSync } from '../../template-catalog-rendering/index.js';
 import { getWorkflowMutationReadiness } from '../../workflow-mutation-readiness/index.js';
-import { getSelectedAgentsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../workflow-target-planning/index.js';
-export async function handleUseSkill(command) {
+import { getSelectedAgentsFromState, getSelectedMcpServersFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../workflow-target-planning/index.js';
+const defaultDependencies = {
+    askForNotionDocsParentPage,
+};
+export async function handleUseSkill(command, dependencies = defaultDependencies) {
     const { rootPath, statePath } = getProjectContext();
     const readiness = getWorkflowMutationReadiness({ rootPath, statePath });
     if (!readiness.ok) {
@@ -34,7 +38,7 @@ export async function handleUseSkill(command) {
             process.exitCode = 1;
             return;
         case 'selected':
-            applySelectedSkill({ rootPath, statePath, state: readiness.state, selectionResult });
+            await applySelectedSkill({ rootPath, statePath, state: readiness.state, selectionResult, dependencies });
             return;
     }
 }
@@ -132,7 +136,7 @@ export function getNextSkillSelection(state, skillName) {
             };
     }
 }
-function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
+async function applySelectedSkill({ rootPath, statePath, state, selectionResult, dependencies, }) {
     const plan = buildSkillApplicationPlan({ rootPath, state, selectionResult });
     const preflightError = getSkillApplicationPreflightError({ rootPath, state, plan });
     if (preflightError) {
@@ -141,25 +145,37 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         process.exitCode = 1;
         return;
     }
-    const agentsContents = renderTemplateForSync({
-        templateRelativePath: plan.agentsTarget.templateRelativePath,
-        currentPath: plan.agentsTarget.targetPath,
+    const mcpServerConfigs = await getNextMcpServerConfigs({ state, selectedMcpServers: plan.selectedMcpServers, dependencies });
+    const dependencyMcpServers = plan.selectedMcpServers.filter((server) => !(state.selectedMcpServers ?? []).includes(server.id));
+    for (const server of dependencyMcpServers) {
+        log.info(`${selectionResult.skillName} requires ${server.name}. I will add them together.`);
+    }
+    const nonAgentTargets = plan.affectedTargets.filter((target) => target.label !== 'AGENTS.md');
+    const files = renderMissingWorkflowFiles({
+        missingTargets: nonAgentTargets,
         selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
         selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
         selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
+        selectedMcpServers: plan.selectedMcpServers,
     });
-    const [newSkillFile] = renderMissingWorkflowFiles({
-        missingTargets: [plan.newSkillTarget],
+    for (const file of files) {
+        const fileAlreadyExists = fs.existsSync(file.targetPath);
+        fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
+        fs.writeFileSync(file.targetPath, file.contents, fileAlreadyExists ? 'utf8' : { encoding: 'utf8', flag: 'wx' });
+        log.success(`${fileAlreadyExists ? 'Updated' : 'Created'} ${file.label}`);
+    }
+    const agentsContents = renderTemplateForSync({
+        templateRelativePath: plan.agentsTarget.templateRelativePath,
+        currentPath: plan.agentsTarget.targetPath,
         selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
         selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
+        selectedMcpServers: plan.selectedMcpServers,
     });
-    fs.mkdirSync(path.dirname(newSkillFile.targetPath), { recursive: true });
-    fs.writeFileSync(newSkillFile.targetPath, newSkillFile.contents, { encoding: 'utf8', flag: 'wx' });
-    log.success(`Created ${newSkillFile.label}`);
     fs.writeFileSync(plan.agentsTarget.targetPath, agentsContents, 'utf8');
     log.success('Updated AGENTS.md skill routing');
     writeSibuState({
@@ -171,43 +187,79 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
         selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
         selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
+        selectedMcpServers: plan.selectedMcpServers,
+        mcpServerConfigs,
         targets: plan.targets,
     });
     log.success(`Updated ${STATE_RELATIVE_PATH}`);
     log.success(`Added ${selectionResult.skillName}.`);
+    for (const server of dependencyMcpServers) {
+        log.success(`Added ${server.name}.`);
+    }
 }
 function buildSkillApplicationPlan({ rootPath, state, selectionResult, }) {
     const selectedAgents = getSelectedAgentsFromState(state);
-    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill), getSelectedWorkflowSkillsFromState(state), getSelectedDatabaseSkillsFromState(state));
-    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill, selectionResult.selection.selectedWorkflowSkills, selectionResult.selection.selectedDatabaseSkills);
+    const currentMcpServers = getSelectedMcpServersFromState(state);
+    const requiredMcpServers = getMcpServersRequiredByWorkflowSkills(selectionResult.selection.selectedWorkflowSkills.map((skill) => skill.id));
+    const selectedMcpServers = mergeMcpServers(currentMcpServers, requiredMcpServers);
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill), getSelectedWorkflowSkillsFromState(state), getSelectedDatabaseSkillsFromState(state), currentMcpServers);
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill, selectionResult.selection.selectedWorkflowSkills, selectionResult.selection.selectedDatabaseSkills, selectedMcpServers);
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
-    const newSkillTarget = targets.find((target) => !previousTargetPaths.has(target.targetPath));
+    const newTargets = targets.filter((target) => !previousTargetPaths.has(target.targetPath) && (target.targetKind === 'skill' || target.targetKind === 'mcp-config'));
+    const mcpConfigTargets = targets.filter((target) => target.mcpConfigAgentId && selectedMcpServers.length > currentMcpServers.length);
     const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
-    if (!newSkillTarget) {
+    if (newTargets.length === 0) {
         throw new Error(`No new workflow target found for ${selectionResult.skillName}.`);
     }
     if (!agentsTarget) {
         throw new Error('AGENTS.md target is missing from workflow targets.');
     }
-    return { agentsTarget, newSkillTarget, targets, selectedAgents };
+    const affectedTargets = dedupeTargets([...newTargets, ...mcpConfigTargets, agentsTarget]);
+    return { agentsTarget, newTargets, affectedTargets, targets, selectedAgents, selectedMcpServers };
 }
 function getSkillApplicationPreflightError({ rootPath, state, plan }) {
-    if (fs.existsSync(plan.newSkillTarget.targetPath)) {
-        return `${path.relative(rootPath, plan.newSkillTarget.targetPath)} already exists but is not recorded for this selection.`;
+    const existingRecordedTargets = plan.affectedTargets.filter((target) => state.managedFiles[path.relative(rootPath, target.targetPath)]);
+    const newTargets = plan.affectedTargets.filter((target) => !state.managedFiles[path.relative(rootPath, target.targetPath)]);
+    for (const target of newTargets) {
+        if (fs.existsSync(target.targetPath)) {
+            return `${path.relative(rootPath, target.targetPath)} already exists but is not recorded for this selection.`;
+        }
     }
-    const agentsRelativePath = path.relative(rootPath, plan.agentsTarget.targetPath);
-    const agentsManagedFile = state.managedFiles[agentsRelativePath];
-    if (!agentsManagedFile) {
-        return 'AGENTS.md is not recorded in `.sibu/state.json`.';
+    for (const target of existingRecordedTargets) {
+        const relativePath = path.relative(rootPath, target.targetPath);
+        const managedFile = state.managedFiles[relativePath];
+        if (!managedFile) {
+            return `${relativePath} is not recorded in ${STATE_RELATIVE_PATH}.`;
+        }
+        if (!fs.existsSync(target.targetPath)) {
+            return `${relativePath} is missing.`;
+        }
+        const currentHash = sha256(fs.readFileSync(target.targetPath, 'utf8'));
+        if (currentHash !== managedFile.sha256) {
+            return `${relativePath} has changed since Sibu last recorded it.`;
+        }
     }
-    if (!fs.existsSync(plan.agentsTarget.targetPath)) {
-        return 'AGENTS.md is missing.';
+    return undefined;
+}
+function dedupeTargets(targets) {
+    return [...new Map(targets.map((target) => [target.targetPath, target])).values()];
+}
+function mergeMcpServers(...serverGroups) {
+    const serversById = new Map();
+    for (const server of serverGroups.flat()) {
+        serversById.set(server.id, server);
     }
-    const agentsCurrentHash = sha256(fs.readFileSync(plan.agentsTarget.targetPath, 'utf8'));
-    if (agentsCurrentHash !== agentsManagedFile.sha256) {
-        return 'AGENTS.md has changed since Sibu last recorded it.';
+    return [...serversById.values()];
+}
+async function getNextMcpServerConfigs({ state, selectedMcpServers, dependencies, }) {
+    if (!selectedMcpServers.some((server) => server.id === 'notion') || state.selectedMcpServers?.includes('notion')) {
+        return state.mcpServerConfigs;
     }
-    return undefined;
+    const docsParentPage = await dependencies.askForNotionDocsParentPage();
+    return {
+        ...state.mcpServerConfigs,
+        notion: { docsParentPage },
+    };
 }
 function getSelectedLanguageSkillsFromState(state) {
     return (state.selectedLanguageSkills ?? []).map(getLanguageSkillById);

package/bin/modules/sync-review/apply-action.js

@@ -13,6 +13,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
     const currentTemplateVersion = preview.currentTemplateVersion ?? getTemplateVersion(manifest, managedFile.template);
     switch (action) {
         case 'apply-update': {
+            recordImpliedWorkflowSkill(nextState, preview);
             const contents = renderTemplateForSync({
                 templateRelativePath: managedFile.template,
                 currentPath: targetPath,
@@ -37,6 +38,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
             return { state: nextState, changedFiles: true, changedState: true };
         }
         case 'mark-reviewed': {
+            recordImpliedWorkflowSkill(nextState, preview);
             const contents = fs.readFileSync(targetPath, 'utf8');
             nextState.templateVersion = manifest.templateVersion;
             nextState.updatedAt = new Date().toISOString();
@@ -85,3 +87,12 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
             return { state, changedFiles: false, changedState: false };
     }
 }
+function recordImpliedWorkflowSkill(state, preview) {
+    if (!preview.impliedWorkflowSkillId) {
+        return;
+    }
+    if (state.selectedWorkflowSkills?.includes(preview.impliedWorkflowSkillId)) {
+        return;
+    }
+    state.selectedWorkflowSkills = [...(state.selectedWorkflowSkills ?? []), preview.impliedWorkflowSkillId];
+}

package/bin/modules/sync-review/sync-preview.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { sha256 } from '../../shared/hash.js';
 import { hasReviewedTemplateVersion } from '../workflow-state-registry/index.js';
 import { renderTemplateForSync } from '../template-catalog-rendering/index.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
     'new-template',
     'missing',
@@ -32,7 +32,19 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
     const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
     const selectedMcpServers = getSelectedMcpServersFromState(state);
-    const previews = Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectedMcpServers.map((server) => server.id));
+    const plannedWorkflowSkills = mergeWorkflowSkills(selectedWorkflowSkills, impliedWorkflowSkills);
+    const missingImpliedWorkflowSkills = impliedWorkflowSkills.filter((skill) => !selectedWorkflowSkills.some((selectedSkill) => selectedSkill.id === skill.id));
+    const previews = [];
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, plannedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
+    const alreadyPreviewedPaths = new Set();
+    for (const skill of missingImpliedWorkflowSkills) {
+        for (const preview of getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, workflowSkill: skill })) {
+            previews.push(preview);
+            alreadyPreviewedPaths.add(preview.relativePath);
+        }
+    }
+    previews.push(...Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
         rootPath,
         manifest,
         relativePath,
@@ -40,46 +52,65 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
-        selectedWorkflowSkills,
+        selectedWorkflowSkills: plannedWorkflowSkills,
         selectedDatabaseSkills,
         selectedMcpServers,
-    }));
-    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
+    })));
     for (const target of expectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
-        if (state.managedFiles[relativePath]) {
-            continue;
-        }
-        const template = manifest.templates[target.templateRelativePath];
-        if (!template) {
-            previews.push({
-                relativePath,
-                managedFile: {
-                    template: target.templateRelativePath,
-                    templateVersion: 'unknown',
-                    sha256: '',
-                },
-                status: 'unknown-template',
-                changes: [],
-                hasLocalFile: fs.existsSync(target.targetPath),
-            });
+        if (state.managedFiles[relativePath] || alreadyPreviewedPaths.has(relativePath)) {
             continue;
         }
-        previews.push({
+        previews.push(getNewExpectedTargetPreview({ rootPath, manifest, target }));
+    }
+    return previews;
+}
+function getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, workflowSkill, }) {
+    const workflowSkillTargetPaths = new Set(Object.values(workflowSkill.targetRelativePathsByAgent));
+    return expectedTargets
+        .filter((target) => workflowSkillTargetPaths.has(path.relative(rootPath, target.targetPath)))
+        .filter((target) => !state.managedFiles[path.relative(rootPath, target.targetPath)])
+        .map((target) => ({
+        ...getNewExpectedTargetPreview({ rootPath, manifest, target }),
+        impliedWorkflowSkillId: workflowSkill.id,
+    }));
+}
+function getNewExpectedTargetPreview({ rootPath, manifest, target }) {
+    const relativePath = path.relative(rootPath, target.targetPath);
+    const template = manifest.templates[target.templateRelativePath];
+    if (!template) {
+        return {
             relativePath,
             managedFile: {
                 template: target.templateRelativePath,
-                templateVersion: template.version,
+                templateVersion: 'unknown',
                 sha256: '',
-                status: 'managed',
             },
-            status: 'new-template',
-            currentTemplateVersion: template.version,
-            changes: template.changes,
+            status: 'unknown-template',
+            changes: [],
             hasLocalFile: fs.existsSync(target.targetPath),
-        });
+        };
     }
-    return previews;
+    return {
+        relativePath,
+        managedFile: {
+            template: target.templateRelativePath,
+            templateVersion: template.version,
+            sha256: '',
+            status: 'managed',
+        },
+        status: 'new-template',
+        currentTemplateVersion: template.version,
+        changes: template.changes,
+        hasLocalFile: fs.existsSync(target.targetPath),
+    };
+}
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
 }
 function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers, }) {
     if (managedFile.status === 'unmanaged') {

package/bin/modules/workflow-target-planning/catalog.js

@@ -71,6 +71,15 @@ export const MANDATORY_SKILLS = [
             windsurf: '.agents/skills/ai-implementation-plan-executor/SKILL.md',
         },
     },
+    {
+        templateRelativePath: 'skills/feature-idea-capture/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/feature-idea-capture/SKILL.md',
+            gemini: '.agents/skills/feature-idea-capture/SKILL.md',
+            claude: '.agents/skills/feature-idea-capture/SKILL.md',
+            windsurf: '.agents/skills/feature-idea-capture/SKILL.md',
+        },
+    },
 ];
 export const SELECTABLE_LANGUAGE_SKILLS = [
     {
@@ -211,7 +220,60 @@ export const SELECTABLE_WORKFLOW_SKILLS = [
             windsurf: '.agents/skills/ux-expert/SKILL.md',
         },
     },
+    {
+        id: 'export-to-github',
+        name: 'Export to GitHub',
+        description: "Install guidance for exporting a named feature's Epics and User Stories to GitHub using the configured GitHub MCP server",
+        routingInstruction: "For exporting a feature's Epics and User Stories to GitHub issues or sub-issues, use `export-to-github`.",
+        templateRelativePath: 'skills/export-to-github/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/export-to-github/SKILL.md',
+            gemini: '.agents/skills/export-to-github/SKILL.md',
+            claude: '.agents/skills/export-to-github/SKILL.md',
+            windsurf: '.agents/skills/export-to-github/SKILL.md',
+        },
+    },
+    {
+        id: 'export-to-notion',
+        name: 'Export to Notion',
+        description: "Install guidance for exporting a named feature's feature brief, UX design, and technical design to Notion using the configured Notion MCP server",
+        routingInstruction: "For exporting a feature's feature brief, UX design, or technical design to Notion, use `export-to-notion`.",
+        templateRelativePath: 'skills/export-to-notion/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/export-to-notion/SKILL.md',
+            gemini: '.agents/skills/export-to-notion/SKILL.md',
+            claude: '.agents/skills/export-to-notion/SKILL.md',
+            windsurf: '.agents/skills/export-to-notion/SKILL.md',
+        },
+    },
 ];
+const EXPORT_WORKFLOW_SKILL_MCP_REQUIREMENTS = {
+    'export-to-github': 'github',
+    'export-to-notion': 'notion',
+};
+export function getMcpServersRequiredByWorkflowSkills(workflowSkillIds) {
+    const requiredServerIds = new Set();
+    for (const workflowSkillId of workflowSkillIds) {
+        const requiredServerId = getRequiredMcpServerIdForWorkflowSkill(workflowSkillId);
+        if (requiredServerId) {
+            requiredServerIds.add(requiredServerId);
+        }
+    }
+    return SELECTABLE_MCP_SERVERS.filter((server) => requiredServerIds.has(server.id));
+}
+export function getWorkflowSkillsImpliedByMcpServers(mcpServerIds) {
+    const selectedServerIds = new Set(mcpServerIds);
+    const impliedSkillIds = Object.entries(EXPORT_WORKFLOW_SKILL_MCP_REQUIREMENTS)
+        .filter(([, requiredServerId]) => selectedServerIds.has(requiredServerId))
+        .map(([workflowSkillId]) => workflowSkillId);
+    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => impliedSkillIds.includes(skill.id));
+}
+function getRequiredMcpServerIdForWorkflowSkill(workflowSkillId) {
+    if (workflowSkillId === 'export-to-github' || workflowSkillId === 'export-to-notion') {
+        return EXPORT_WORKFLOW_SKILL_MCP_REQUIREMENTS[workflowSkillId];
+    }
+    return undefined;
+}
 export const SELECTABLE_MCP_SERVERS = [
     {
         id: 'github',

package/bin/modules/workflow-target-planning/index.js

@@ -1,2 +1,2 @@
-export { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, resolveSelectableMcpServerById, resolveSelectableSkillById, } from './catalog.js';
+export { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, getMcpServersRequiredByWorkflowSkills, getWorkflowSkillsImpliedByMcpServers, resolveSelectableMcpServerById, resolveSelectableSkillById, } from './catalog.js';
 export { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedMcpTargetsForAgents, getSelectedSkillTargetsForAgents, getSelectedWorkflowSkillsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState, } from './workflow-targets.js';

package/package.json

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

package/templates/AGENTS.md

@@ -47,6 +47,7 @@ For planned product/feature work, use this pipeline: product vision -> deep modu
 - 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 explicit planning-only requests to turn a specific User Story into an implementation checklist, coding plan, step-by-step execution plan, or baby-step plan without implementation, use `ai-implementation-planner` and stop after writing the plan. Treat a request as planning-only only when the user explicitly says planning-only, "do not implement," or asks to create the plan without execution.
 - For requests to plan, implement, execute, continue, or work through a specific User Story under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.md`, an Epic, 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`; when the story plan is missing, the executor must create it with `ai-implementation-planner` and immediately continue into implementation without a separate plan approval gate.
+- For requests to capture, save, jot down, or add rough future feature ideas, use `feature-idea-capture`.
 {{OPTIONAL_SKILL_ROUTING}}
 
 ## Sibu maintenance

package/templates/manifest.json

@@ -1,11 +1,11 @@
 {
-  "templateVersion": "98",
+  "templateVersion": "103",
   "templates": {
     "AGENTS.md": {
-      "version": "29",
+      "version": "30",
       "description": "Project-level agent instructions and Sibu maintenance guidance.",
       "changes": [
-        "Can render Layered Architecture routing when that architecture option is selected."
+        "Routes rough future idea capture requests to the mandatory feature-idea-capture skill."
       ]
     },
     ".codex/config.toml": {
@@ -65,17 +65,17 @@
       ]
     },
     "skills/feature-brief-writer/SKILL.md": {
-      "version": "10",
+      "version": "13",
       "description": "Mandatory feature brief writer skill installed once at the shared .agents/skills workspace path.",
       "changes": [
-        "Adds optional Notion export guidance after local feature briefs are written while keeping Markdown as the canonical artifact."
+        "Keeps feature brief writing focused on local Markdown artifacts and moves Notion export workflow guidance to dedicated exporter skills."
       ]
     },
     "skills/technical-design-writer/SKILL.md": {
-      "version": "18",
+      "version": "19",
       "description": "Mandatory technical design writer skill installed once at the shared .agents/skills workspace path.",
       "changes": [
-        "Strengthens technical design interviews to resolve material implementation questions before drafting and replaces open questions with risks/tradeoffs."
+        "Keeps technical design writing focused on local Markdown artifacts and moves Notion export workflow guidance to dedicated exporter skills."
       ]
     },
     "skills/typescript/SKILL.md": {
@@ -128,10 +128,10 @@
       ]
     },
     "skills/scrum-master-planner/SKILL.md": {
-      "version": "11",
+      "version": "12",
       "description": "Mandatory Scrum planner skill for creating pragmatic Epics and User Stories from approved feature and technical design docs.",
       "changes": [
-        "Clarifies that User Stories should be deployable increments that can be merged safely on their own, even when gated or incomplete until the parent Epic is done."
+        "Keeps Scrum planning focused on local Epic and User Story artifacts and moves GitHub export workflow guidance to dedicated exporter skills."
       ]
     },
     "skills/ai-implementation-planner/SKILL.md": {
@@ -148,6 +148,13 @@
         "Clarifies that story and Epic planning requests are confirmation for executor implementation."
       ]
     },
+    "skills/feature-idea-capture/SKILL.md": {
+      "version": "1",
+      "description": "Mandatory feature idea capture skill for storing rough future ideas in docs/feature-ideas.md only when the skill is used.",
+      "changes": [
+        "Adds a mandatory feature idea capture skill for quick, raw idea storage without backlog or planning ceremony."
+      ]
+    },
     "skills/ai-prompt-engineer-master/SKILL.md": {
       "version": "2",
       "description": "Selectable AI prompt engineering skill for prompt creation, optimization, compression, and evaluation.",
@@ -156,10 +163,10 @@
       ]
     },
     "skills/ux-expert/SKILL.md": {
-      "version": "8",
+      "version": "9",
       "description": "Selectable UX expert skill for UI-changing features, responsive design, flows, states, accessibility, and binding mockups.",
       "changes": [
-        "Strengthens UX interviews to resolve material experience questions before drafting and replaces open UX questions with risks/tradeoffs."
+        "Keeps UX design writing focused on local Markdown artifacts and moves Notion export workflow guidance to dedicated exporter skills."
       ]
     },
     "skills/architecture/layered-architecture/SKILL.md": {
@@ -168,6 +175,20 @@
       "changes": [
         "Adds a Layered Architecture skill for smaller apps that need simple separation of concerns."
       ]
+    },
+    "skills/export-to-github/SKILL.md": {
+      "version": "1",
+      "description": "Selectable GitHub export skill for publishing a named feature's Epics and User Stories to GitHub issues and native sub-issues.",
+      "changes": [
+        "Adds a dedicated GitHub exporter skill paired with GitHub MCP selection."
+      ]
+    },
+    "skills/export-to-notion/SKILL.md": {
+      "version": "1",
+      "description": "Selectable Notion export skill for publishing a named feature's core documentation files to Notion.",
+      "changes": [
+        "Adds a dedicated Notion exporter skill paired with Notion MCP selection."
+      ]
     }
   }
 }

package/templates/skills/export-to-github/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: export-to-github
+description: Export a named feature's Epics and User Stories from local Markdown to GitHub issues and native sub-issues using configured GitHub MCP capabilities.
+---
+
+# Export to GitHub
+
+Use this skill when the user asks to export a feature's Epics and User Stories to GitHub.
+
+## Required input
+
+- A feature name or feature slug.
+- Local planning artifacts under `docs/features/<feature-slug>/epics/`.
+- Configured GitHub MCP capabilities for issue creation, issue ID access, and native sub-issue mutation.
+
+If the feature name is ambiguous, inspect `docs/features/` and ask one focused clarification question.
+
+## Workflow
+
+1. Resolve the feature slug from the user's feature name.
+2. Read the feature's Epic briefs and User Story Markdown files under `docs/features/<feature-slug>/epics/**`.
+3. Resolve the target repository from the current local repo's GitHub `origin` remote only. Do not ask for or use another repository.
+4. Verify GitHub MCP can create issues, return issue IDs, and attach native sub-issues.
+5. Ask one explicit opt-in question before any GitHub mutation.
+6. If the user accepts, create a fresh issue set every time:
+   - one issue per Epic, with no labels
+   - one issue per User Story, with no labels
+   - each User Story issue attached as a native sub-issue of its parent Epic issue
+7. Report created issue numbers or URLs.
+
+## Export rules
+
+- Keep issue bodies concise and source-grounded.
+- Include the source local doc path and relevant summary, scope, acceptance criteria, or validation notes.
+- Preserve each created User Story issue's GitHub issue `id`; native sub-issue APIs need the child issue ID, not only its issue number.
+- Do not search for duplicates or update existing issues.
+- Do not use labels, milestones, projects, assignees, status tracking, Markdown checklists, or loose links as a substitute for native sub-issues.
+- Do not modify local Markdown files with GitHub URLs.
+- If issue creation, issue ID access, or native sub-issue attachment is unavailable, fail clearly and do not fall back to another structure.

package/templates/skills/export-to-notion/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: export-to-notion
+description: Export a named feature's local feature brief, UX design, and technical design Markdown files to Notion using configured Notion MCP capabilities.
+---
+
+# Export to Notion
+
+Use this skill when the user asks to export a feature's core documentation to Notion.
+
+## Required input
+
+- A feature name or feature slug.
+- Configured Notion MCP capabilities.
+- `.sibu/state.json` with `mcpServerConfigs.notion.docsParentPage` when available.
+
+If the feature name is ambiguous, inspect `docs/features/` and ask one focused clarification question.
+
+## Source files
+
+Export only these local Markdown files when present:
+
+```txt
+docs/features/<feature-slug>/feature_brief.md
+docs/features/<feature-slug>/ux.md
+docs/features/<feature-slug>/technical_design.md
+```
+
+Do not export Epics, User Stories, implementation plans, product vision, Deep Module Maps, or arbitrary docs with this skill.
+
+## Notion destination
+
+Use this organization under the configured Notion docs parent page:
+
+```txt
+<docsParentPage>
+└── <repo name>
+    └── Features
+        └── <feature name>
+            ├── Feature Brief
+            ├── UX Design
+            └── Technical Design
+```
+
+## Workflow
+
+1. Resolve the feature slug from the user's feature name.
+2. Read `.sibu/state.json` when available and use `mcpServerConfigs.notion.docsParentPage` as the destination parent.
+3. Confirm which of the allowed source files exist.
+4. Ask one explicit opt-in question before creating or modifying Notion pages.
+5. Create or reuse the repo, Features, and feature organization pages under the configured parent.
+6. Export each existing allowed artifact to its matching Notion page.
+7. Report export success or failure per artifact.
+
+## Export rules
+
+- Local Markdown remains canonical.
+- Do not write Notion URLs back into local Markdown.
+- Do not invent missing source artifacts.
+- Do not export files outside the allowed source list.
+- If Notion MCP capabilities or destination configuration are unavailable, fail clearly and explain what is missing.

package/templates/skills/feature-brief-writer/SKILL.md

@@ -95,6 +95,17 @@ Use a short kebab-case feature slug that matches the feature name. Keep all arti
 
 Do not write the brief to technical design, UX, user story, implementation plan, or backlog files unless the user explicitly asks for a separate artifact after the feature brief exists.
 
+## Raw idea sources
+
+If the user asks for a feature brief from an idea in `docs/feature-ideas.md`, read the relevant idea and treat it as raw/vague input only.
+
+- Do not skip the normal interview flow because the idea exists in a file.
+- Use the idea as a seed for the first discovery question, not as complete feature intent.
+- Keep asking one focused question at a time until the usual required context is resolved: problem, target user/scenario, business goal, MVP boundary, out-of-scope boundary, success signals, constraints, and Deep Module fit.
+- Preserve the hard-start requirements for `docs/product-vision.md` and `docs/deep-module-map.md`.
+- After the local `docs/features/<feature-slug>/feature_brief.md` file is successfully written, remove the promoted idea from `docs/feature-ideas.md` while preserving the rest of the file.
+- Do not delete the idea before the feature brief file exists, and do not remove unrelated ideas or headings.
+
 ## Interview posture
 
 Be deliberately interrogative before drafting. The feature brief should reflect the user's intent, not the assistant's assumptions.
@@ -283,31 +294,6 @@ When shaping a feature brief, prefer:
 7. measurable success signals
 8. non-technical acceptance criteria
 
-## Optional Notion export after local write
-
-After the local Markdown file is written successfully, optionally offer Notion export. Local Markdown remains the canonical pipeline artifact and Notion is only a convenience export destination.
-
-1. Do not check Notion export before the local file exists.
-2. After writing the local file, read `.sibu/state.json` if available.
-3. Offer export only when all are true:
-   - `selectedMcpServers` includes `notion`
-   - `mcpServerConfigs.notion.docsParentPage` is present
-   - Notion MCP tools are available in the current agent session
-4. If export is unavailable, do nothing else and finish with the normal local path response.
-5. If export is available, ask for explicit opt-in before creating or modifying any Notion page.
-6. If the user declines, do nothing else.
-7. If the user accepts, create or reuse Notion organization pages under the configured parent page:
-
-```txt
-<docsParentPage>
-└── <repo name>
-    └── Features
-        └── <feature name>
-            └── Feature Brief
-```
-
-Create a new document page for the just-written artifact content. Do not write Notion URLs back into local Markdown. Report Notion export success or a clear Notion export failure, while preserving the local file as the completed artifact either way.
-
 ## Final response behavior
 
 After writing the file, final-answer with only the path created or updated. Do not paste the feature brief body, excerpt, outline, or section summaries.

package/templates/skills/feature-idea-capture/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: feature-idea-capture
+description: Use when the user wants to capture, save, jot down, or add a rough future feature, product, workflow, or improvement idea without turning it into a backlog item, feature brief, or implementation task.
+---
+
+# Feature Idea Capture
+
+Capture rough future ideas quickly in `docs/feature-ideas.md`.
+
+## Behavior
+
+- Write the idea down directly. Do not interview the user before capture.
+- Keep the idea intentionally raw: a short heading and a few bullets are enough.
+- If `docs/feature-ideas.md` does not exist, create it on first use.
+- Append new ideas; do not classify, prioritize, groom, or turn them into backlog work.
+- Do not create feature briefs, epics, stories, implementation plans, or code from captured ideas unless the user separately asks for that later.
+- Do not migrate, rename, inspect, or reconcile pre-existing alternate idea files.
+
+## File shape
+
+Use this lightweight shape:
+
+```md
+# Feature Ideas
+
+## <Idea title>
+
+- <Short note>
+- <Short note>
+```
+
+If the file already exists, preserve its current content and append the new idea using the same simple style.

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

@@ -213,37 +213,6 @@ Before finishing, verify:
 - no Story adds scope that is absent from the feature brief or technical design
 - acceptance criteria are testable enough for a reviewer
 
-### 6. Mandatory GitHub export gate
-
-After all local Epic and User Story files are written, you must run the GitHub export gate before the final response. This gate is mandatory whenever Scrum planning creates or updates local Epic or User Story files.
-
-Do not skip the gate because the user did not mention GitHub. Do not assume GitHub MCP is unavailable. Explicitly check whether GitHub MCP tools are available for issue creation, issue ID access, and native sub-issue mutation.
-
-If any required GitHub MCP capability is unavailable, do not offer GitHub export. In the final response, include a single concise note that GitHub export was skipped because the required GitHub MCP capabilities were unavailable.
-
-If the required GitHub MCP capabilities are available:
-
-1. Resolve the target repository from the current local repo's GitHub `origin` remote only. Do not ask for or use another repository.
-2. Ask one explicit opt-in question before any GitHub mutation: "GitHub MCP is available. Create GitHub Issues for these Epics and User Stories in the current repo?"
-3. If the user declines, perform no GitHub mutation.
-4. If the user accepts, create a fresh issue set every time. Do not search for duplicates or update existing issues.
-5. Create one issue per Epic with no labels.
-6. Create one issue per User Story with no labels.
-7. Attach each User Story issue as a native GitHub sub-issue of its parent Epic issue.
-8. Report created issue numbers or URLs.
-
-Keep issue bodies concise and source-grounded. Include the source local doc path and relevant summary, scope, acceptance criteria, or validation notes. Do not modify local Markdown files with GitHub URLs.
-
-Native sub-issues are required for this export. Preserve each created User Story issue's GitHub issue `id` because native sub-issue APIs need the child issue ID, not only its issue number. If issue creation, issue ID access, or native sub-issue attachment fails or is unavailable, fail clearly and do not fall back to labels, Markdown checklists, loose links, GitHub Projects, milestones, assignees, or status tracking.
-
-Passing the gate means exactly one of these outcomes occurred:
-
-- GitHub MCP was unavailable or incomplete, and the final response says export was skipped for that reason.
-- GitHub MCP was available, the user declined export, and no GitHub mutation occurred.
-- GitHub MCP was available, the user accepted export, and the created issue numbers or URLs are reported.
-
-Never finish a Scrum planning run without one of these three GitHub export outcomes.
-
 ## Final response behavior
 
 After writing files, final-answer with only:
@@ -251,6 +220,5 @@ After writing files, final-answer with only:
 - the Epic directories created or updated
 - the number of Epics and User Stories
 - any source-scope items intentionally left unresolved or captured as risks
-- the GitHub export gate outcome
 
 Do not paste artifact bodies, excerpts, outlines, story text, acceptance criteria, or section summaries. Only include generated artifacts when the user explicitly asks for inline review in the current request.

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

@@ -173,31 +173,6 @@ Use this structure as a starting point. Delete sections that do not add value.
 
 A good technical design is short, specific, and useful. It should not try to be the product brief, architecture skill, clean-code skill, implementation plan, or ticket backlog.
 
-## Optional Notion export after local write
-
-After the local Markdown file is written successfully, optionally offer Notion export. Local Markdown remains the canonical pipeline artifact and Notion is only a convenience export destination.
-
-1. Do not check Notion export before the local file exists.
-2. After writing the local file, read `.sibu/state.json` if available.
-3. Offer export only when all are true:
-   - `selectedMcpServers` includes `notion`
-   - `mcpServerConfigs.notion.docsParentPage` is present
-   - Notion MCP tools are available in the current agent session
-4. If export is unavailable, do nothing else and finish with the normal local path response.
-5. If export is available, ask for explicit opt-in before creating or modifying any Notion page.
-6. If the user declines, do nothing else.
-7. If the user accepts, create or reuse Notion organization pages under the configured parent page:
-
-```txt
-<docsParentPage>
-└── <repo name>
-    └── Features
-        └── <feature name>
-            └── Technical Design
-```
-
-Create a new document page for the just-written artifact content. Do not write Notion URLs back into local Markdown. Report Notion export success or a clear Notion export failure, while preserving the local file as the completed artifact either way.
-
 ## Final response behavior
 
 After writing the file, final-answer with only the path created or updated. Do not paste the technical design body, excerpt, outline, or section summaries.

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

@@ -133,31 +133,6 @@ Use only helpful sections from this shape:
 
 The Binding Mockups section is authoritative for downstream work unless this UX spec is revised.
 
-## Optional Notion export after local write
-
-After the local Markdown file is written successfully, optionally offer Notion export. Local Markdown remains the canonical pipeline artifact and Notion is only a convenience export destination.
-
-1. Do not check Notion export before the local file exists.
-2. After writing the local file, read `.sibu/state.json` if available.
-3. Offer export only when all are true:
-   - `selectedMcpServers` includes `notion`
-   - `mcpServerConfigs.notion.docsParentPage` is present
-   - Notion MCP tools are available in the current agent session
-4. If export is unavailable, do nothing else and finish with the normal local path response.
-5. If export is available, ask for explicit opt-in before creating or modifying any Notion page.
-6. If the user declines, do nothing else.
-7. If the user accepts, create or reuse Notion organization pages under the configured parent page:
-
-```txt
-<docsParentPage>
-└── <repo name>
-    └── Features
-        └── <feature name>
-            └── UX Design
-```
-
-Create a new document page for the just-written artifact content. Do not write Notion URLs back into local Markdown. Report Notion export success or a clear Notion export failure, while preserving the local file as the completed artifact either way.
-
 ## Final response behavior
 
 After writing the file, final-answer with only the path created or updated. Do not paste the UX spec body, excerpt, outline, mockups, or section summaries.

package/bin/shared/templates.js

@@ -1,60 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { getTemplatesPath } from './paths.js';
-export function readTemplate(relativePath) {
-    return fs.readFileSync(path.join(getTemplatesPath(), relativePath), 'utf8');
-}
-export function readTemplateManifest() {
-    const manifest = JSON.parse(fs.readFileSync(path.join(getTemplatesPath(), 'manifest.json'), 'utf8'));
-    if (!isTemplateManifest(manifest)) {
-        throw new Error('templates/manifest.json is not a valid template manifest.');
-    }
-    return manifest;
-}
-export function getTemplateVersion(manifest, templateRelativePath) {
-    const template = manifest.templates[templateRelativePath];
-    if (!template) {
-        throw new Error(`Template ${templateRelativePath} is missing from templates/manifest.json.`);
-    }
-    return template.version;
-}
-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, selectedWorkflowSkills);
-}
-export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
-    if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
-        return contents;
-    }
-    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []), ...selectedWorkflowSkills]
-        .map((skill) => `- ${skill.routingInstruction}`)
-        .join('\n');
-    return contents.replace('{{OPTIONAL_SKILL_ROUTING}}', optionalRouting);
-}
-export function extractProjectOverview(filePath) {
-    if (!fs.existsSync(filePath)) {
-        return undefined;
-    }
-    const contents = fs.readFileSync(filePath, 'utf8');
-    const match = contents.match(/## Project overview\s+([\s\S]*?)(?=\n## |$)/);
-    const overview = match?.[1]?.trim();
-    return overview || undefined;
-}
-function isTemplateManifest(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const manifest = value;
-    return (typeof manifest.templateVersion === 'string' &&
-        !!manifest.templates &&
-        typeof manifest.templates === 'object' &&
-        Object.values(manifest.templates).every((template) => !!template &&
-            typeof template === 'object' &&
-            typeof template.version === 'string' &&
-            typeof template.description === 'string' &&
-            Array.isArray(template.changes) &&
-            template.changes.every((change) => typeof change === 'string')));
-}

package/bin/shared/workflow-targets.js

@@ -1,125 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { SIBU_VERSION } from './catalog.js';
-import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from '../modules/workflow-target-planning/index.js';
-import { sha256 } from './hash.js';
-import { removeUndefinedFields } from './object.js';
-import { readExistingState } from './state.js';
-import { getTemplateVersion, readTemplate, readTemplateManifest, renderSkillRouting } from '../modules/template-catalog-rendering/index.js';
-export function getSelectedLanguageSkillsFromState(state) {
-    return SELECTABLE_LANGUAGE_SKILLS.filter((skill) => state.selectedLanguageSkills?.includes(skill.id));
-}
-export function getSelectedFrameworkSkillsFromState(state) {
-    return SELECTABLE_FRAMEWORK_SKILLS.filter((skill) => state.selectedFrameworkSkills?.includes(skill.id));
-}
-export function getSelectedArchitectureSkillFromState(state) {
-    return SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === state.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) {
-            const targetRelativePath = skill.targetRelativePathsByAgent[agent.id];
-            if (!targetRelativePath) {
-                continue;
-            }
-            skillTargets.set(targetRelativePath, {
-                targetRelativePath,
-                templateRelativePath: skill.templateRelativePath,
-            });
-        }
-    }
-    return [...skillTargets.values()];
-}
-export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = []) {
-    return [
-        {
-            label: 'AGENTS.md',
-            targetPath: path.join(rootPath, 'AGENTS.md'),
-            templateRelativePath: 'AGENTS.md',
-            requiresProjectOverview: true,
-        },
-        ...selectedAgents.flatMap((agent) => {
-            if (!agent.targetRelativePath || !agent.templateRelativePath) {
-                return [];
-            }
-            return [
-                {
-                    label: agent.targetRelativePath,
-                    targetPath: path.join(rootPath, agent.targetRelativePath),
-                    templateRelativePath: agent.templateRelativePath,
-                    requiresProjectOverview: false,
-                },
-            ];
-        }),
-        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills).map((skillTarget) => ({
-            label: skillTarget.targetRelativePath,
-            targetPath: path.join(rootPath, skillTarget.targetRelativePath),
-            templateRelativePath: skillTarget.templateRelativePath,
-            requiresProjectOverview: false,
-        })),
-    ];
-}
-export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
-    return missingTargets.map((target) => {
-        let contents = readTemplate(target.templateRelativePath);
-        if (target.requiresProjectOverview) {
-            if (!overview?.trim()) {
-                throw new Error('Project overview is required to create AGENTS.md.');
-            }
-            contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
-        }
-        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
-        return {
-            label: target.label,
-            targetPath: target.targetPath,
-            contents,
-        };
-    });
-}
-export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], targets, }) {
-    const previousState = readExistingState(statePath);
-    const now = new Date().toISOString();
-    const manifest = readTemplateManifest();
-    const state = {
-        sibuVersion: SIBU_VERSION,
-        templateVersion: manifest.templateVersion,
-        generatedAt: previousState?.generatedAt ?? now,
-        updatedAt: now,
-        selectedAgents: selectedAgents.map((agent) => agent.id),
-        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) => {
-            const relativePath = path.relative(rootPath, target.targetPath);
-            const previousManagedFile = previousState?.managedFiles[relativePath];
-            const nextManagedFile = {
-                template: target.templateRelativePath,
-                templateVersion: getTemplateVersion(manifest, target.templateRelativePath),
-                sha256: sha256(fs.readFileSync(target.targetPath, 'utf8')),
-                status: previousManagedFile?.status ?? 'managed',
-                lastReviewedTemplateVersion: previousManagedFile?.lastReviewedTemplateVersion,
-                reason: previousManagedFile?.reason,
-            };
-            return [relativePath, removeUndefinedFields(nextManagedFile)];
-        })),
-    };
-    fs.mkdirSync(path.dirname(statePath), { recursive: true });
-    fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
-}
-export function getSelectedAgentsFromState(state) {
-    return SUPPORTED_AGENTS.filter((agent) => state.selectedAgents.includes(agent.id));
-}