@juancr11/sibu 0.13.2 → 0.15.1

package/bin/admin/release.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createInterface } from 'node:readline/promises';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { previewAndConfirmMaintainerRelease } from '../modules/maintainer-release-support/release-workflow/handler.js';
@@ -166,6 +166,20 @@ function createTerminalPorts() {
                 return commandFailure(error);
             }
         },
+        runInteractive(command, args) {
+            const result = spawnSync(command, args, {
+                stdio: 'inherit',
+            });
+            if (result.error) {
+                return {
+                    exitCode: 1,
+                    stderr: result.error.message,
+                };
+            }
+            return {
+                exitCode: result.status ?? 1,
+            };
+        },
     };
 }
 function printExecutionResult(result, ports) {

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/maintainer-release-support/release-workflow/handler.js

@@ -207,8 +207,9 @@ export async function executeConfirmedRelease(plan, ports) {
     }
     const npmPublishArgs = buildNpmPublishArgs(plan);
     const npmPublishLog = plan.hasOtp ? 'npm publish --access public --otp ******' : 'npm publish --access public';
-    printExecutionProgress(ports, `Publishing package to npm: ${npmPublishLog}...`);
-    const npmPublish = await ports.run('npm', npmPublishArgs);
+    const npmPublishMode = plan.hasOtp ? 'captured OTP publish' : 'interactive browser/2FA-capable publish';
+    printExecutionProgress(ports, `Publishing package to npm: ${npmPublishLog} (${npmPublishMode})...`);
+    const npmPublish = await runNpmPublish(ports, npmPublishArgs, plan);
     if (npmPublish.exitCode !== 0) {
         const failure = failExecution(completedSteps, 'publish-npm', 'Publishing to npm failed.', npmPublish);
         printExecutionFailure(ports, failure);
@@ -272,6 +273,12 @@ function buildNpmPublishArgs(plan) {
     }
     return args;
 }
+function runNpmPublish(ports, args, plan) {
+    if (plan.hasOtp || !ports.runInteractive) {
+        return ports.run('npm', args);
+    }
+    return ports.runInteractive('npm', args);
+}
 async function runStep(ports, completedSteps, stepName, startMessage, command, args, completedMessage) {
     printExecutionProgress(ports, startMessage);
     const result = await ports.run(command, args);

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') {