@stackbilt/cli 0.9.2 → 0.11.0

package/dist/commands/bootstrap.js

@@ -42,6 +42,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bootstrapCommand = bootstrapCommand;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const readline = __importStar(require("node:readline"));
 const crypto = __importStar(require("node:crypto"));
 const node_child_process_1 = require("node:child_process");
 const index_1 = require("../index");
@@ -62,7 +63,9 @@ async function bootstrapCommand(options, args) {
     const presetFlag = (0, flags_1.getFlag)(args, '--preset');
     const skipInstall = args.includes('--skip-install');
     const skipDoctor = args.includes('--skip-doctor');
-    const force = options.yes;
+    const force = args.includes('--force');
+    const nonInteractive = options.yes;
+    const setupOverwrite = options.yes || force;
     if (ciTarget && ciTarget !== 'github') {
         throw new index_1.CLIError(`Unsupported CI target: ${ciTarget}. Supported: github`);
     }
@@ -80,14 +83,13 @@ async function bootstrapCommand(options, args) {
     // ========================================================================
     const detectResult = runDetectPhase(options, presetFlag);
     result.steps.push(detectResult.step);
-    if (detectResult.step.status === 'fail')
-        warnings++;
+    warnings += detectResult.step.warnings.length;
     const selectedPreset = detectResult.selectedPreset;
     const detection = detectResult.detection;
     const contexts = detectResult.contexts;
     const packageManager = detectResult.packageManager;
     if (options.format === 'text') {
-        console.log('[1/6] Detecting stack...');
+        console.log('[1/7] Detecting stack...');
         console.log(`  Stack: ${selectedPreset} (${detection.confidence} confidence)`);
         console.log(`  Monorepo: ${detection.monorepo ? 'yes' : 'no'}${detection.monorepo && detection.signals.hasPnpm ? ' (pnpm workspace)' : ''}`);
         if (detection.warnings.length > 0) {
@@ -100,12 +102,11 @@ async function bootstrapCommand(options, args) {
     // ========================================================================
     // Phase 2: Setup
     // ========================================================================
-    const setupResult = runSetupPhase(options, selectedPreset, detection, contexts, ciTarget, packageManager, force);
+    const setupResult = runSetupPhase(options, selectedPreset, detection, contexts, ciTarget, packageManager, setupOverwrite);
     result.steps.push(setupResult.step);
-    if (setupResult.step.status === 'fail')
-        warnings++;
+    warnings += setupResult.step.warnings.length;
     if (options.format === 'text') {
-        console.log('[2/6] Setting up governance...');
+        console.log('[2/7] Setting up governance...');
         for (const f of (setupResult.step.details.created || [])) {
             console.log(`  Created ${f}`);
         }
@@ -119,27 +120,51 @@ async function bootstrapCommand(options, args) {
     // ========================================================================
     const adfResult = runAdfInitPhase(options, force, selectedPreset);
     result.steps.push(adfResult.step);
-    if (adfResult.step.status === 'fail')
-        warnings++;
+    warnings += adfResult.step.warnings.length;
     if (options.format === 'text') {
-        console.log('[3/6] Initializing ADF context...');
+        console.log('[3/7] Initializing ADF context...');
         for (const f of (adfResult.step.details.files || [])) {
             console.log(`  Created ${f}`);
         }
         for (const f of (adfResult.step.details.pointers || [])) {
             console.log(`  Generated ${f}`);
         }
+        const backedUp = adfResult.step.details.backedUp;
+        if (backedUp && backedUp > 0) {
+            console.log(`  Backed up ${backedUp} files to .ai/.backup/`);
+        }
+        for (const warning of adfResult.step.warnings) {
+            console.log(`  Warning: ${warning}`);
+        }
         console.log('');
     }
+    // Orphan registration: auto-register in --yes mode, prompt interactively otherwise
+    const orphans = adfResult.step.details.orphans || [];
+    if (orphans.length > 0) {
+        let shouldRegister = false;
+        if (nonInteractive) {
+            shouldRegister = true;
+        }
+        else if (options.format === 'text') {
+            shouldRegister = await promptYesNo('  Register these modules now? (y/N) ');
+        }
+        if (shouldRegister) {
+            registerOrphansInManifest(path.join('.ai', 'manifest.adf'), orphans);
+            (0, adf_migrate_1.updateModuleIndex)('CLAUDE.md', '.ai');
+            if (options.format === 'text') {
+                console.log(`  Registered ${orphans.length} module(s) as ON_DEMAND in manifest.adf`);
+                console.log('');
+            }
+        }
+    }
     // ========================================================================
     // Phase 4: Migrate Agent Configs
     // ========================================================================
-    const migrateResult = runMigratePhase(options, force);
+    const migrateResult = runMigratePhase(options, nonInteractive);
     result.steps.push(migrateResult.step);
-    if (migrateResult.step.status === 'fail')
-        warnings++;
+    warnings += migrateResult.step.warnings.length;
     if (options.format === 'text') {
-        console.log('[4/6] Migrating agent configs...');
+        console.log('[4/7] Migrating agent configs...');
         if (migrateResult.step.status === 'skip') {
             console.log('  Skipped (no migratable files)');
         }
@@ -159,10 +184,9 @@ async function bootstrapCommand(options, args) {
     // ========================================================================
     const installResult = runInstallPhase(options, skipInstall);
     result.steps.push(installResult.step);
-    if (installResult.step.status === 'fail')
-        warnings++;
+    warnings += installResult.step.warnings.length;
     if (options.format === 'text') {
-        console.log('[5/6] Installing dependencies...');
+        console.log('[5/7] Installing dependencies...');
         if (skipInstall) {
             console.log('  Skipped (--skip-install)');
         }
@@ -185,14 +209,31 @@ async function bootstrapCommand(options, args) {
         console.log('');
     }
     // ========================================================================
-    // Phase 6: Doctor
+    // Phase 6: Populate (#89)
+    // ========================================================================
+    const populateResult = await runPopulatePhase(options);
+    result.steps.push(populateResult.step);
+    warnings += populateResult.step.warnings.length;
+    if (options.format === 'text') {
+        console.log('[6/7] Auto-populating ADF modules...');
+        const populated = populateResult.step.details.populated;
+        const skipped = populateResult.step.details.skipped;
+        if (populated > 0) {
+            console.log(`  Populated ${populated} module(s), skipped ${skipped} (already customized)`);
+        }
+        else {
+            console.log('  No scaffold content to replace');
+        }
+        console.log('');
+    }
+    // ========================================================================
+    // Phase 7: Doctor
     // ========================================================================
     const doctorResult = runDoctorPhase(options, skipDoctor);
     result.steps.push(doctorResult.step);
-    if (doctorResult.step.status === 'fail')
-        warnings++;
+    warnings += doctorResult.step.warnings.length;
     if (options.format === 'text') {
-        console.log('[6/6] Running health check...');
+        console.log('[7/7] Running health check...');
         if (skipDoctor) {
             console.log('  Skipped (--skip-doctor)');
         }
@@ -212,25 +253,80 @@ async function bootstrapCommand(options, args) {
     result.status = failCount === 0 ? 'success' : failCount < result.steps.length ? 'partial' : 'failure';
     // Build next steps
     result.nextSteps.push({
-        cmd: 'Review .charter/patterns/ and customize for your stack',
+        cmd: 'charter serve  # start MCP server for Claude Code / Cursor integration',
         required: false,
-        reason: 'Customize blessed stack patterns',
+        reason: 'Enable real-time governance via MCP (add to .claude/settings.json)',
     });
     result.nextSteps.push({
-        cmd: 'charter adf populate  # auto-fill ADF files from codebase signals',
+        cmd: 'Review .charter/patterns/ and customize for your stack',
         required: false,
-        reason: 'Populate ADF context from package.json, README, and stack detection',
+        reason: 'Customize blessed stack patterns',
     });
     result.nextSteps.push({
         cmd: 'git add .charter .ai CLAUDE.md .cursorrules agents.md && git commit -m "chore: bootstrap charter governance"',
         required: false,
         reason: 'Commit governance baseline',
     });
+    // ========================================================================
+    // Governance Gaps — surface what's configured but not enforced
+    // ========================================================================
+    const gaps = [];
+    // Check: trailers enabled but no commit-msg hook
+    if (fs.existsSync('.charter/config.json')) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync('.charter/config.json', 'utf-8'));
+            if (cfg.git?.requireTrailers) {
+                const hookPath = path.resolve('.githooks/commit-msg');
+                const gitHookPath = path.resolve('.git/hooks/commit-msg');
+                if (!fs.existsSync(hookPath) && !fs.existsSync(gitHookPath)) {
+                    gaps.push({
+                        gap: 'requireTrailers enabled but no commit-msg hook installed',
+                        fix: 'charter hook install --commit-msg',
+                    });
+                }
+            }
+            if (cfg.drift?.enabled && !ciTarget) {
+                const workflowPath = path.resolve('.github/workflows/charter.yml');
+                if (!fs.existsSync(workflowPath)) {
+                    gaps.push({
+                        gap: 'drift detection enabled but no CI workflow',
+                        fix: 'charter bootstrap --ci github (or add manually)',
+                    });
+                }
+            }
+        }
+        catch { /* config not parseable — doctor already caught it */ }
+    }
+    // Check: no SECURITY.md
+    if (!fs.existsSync('SECURITY.md')) {
+        gaps.push({
+            gap: 'no SECURITY.md for responsible disclosure',
+            fix: 'add SECURITY.md with reporting contact and supported versions',
+        });
+    }
+    // Check: no pre-commit hook for ADF evidence
+    const preCommitHook = path.resolve('.githooks/pre-commit');
+    const gitPreCommit = path.resolve('.git/hooks/pre-commit');
+    if (!fs.existsSync(preCommitHook) && !fs.existsSync(gitPreCommit)) {
+        gaps.push({
+            gap: 'no pre-commit hook for ADF evidence gate',
+            fix: 'charter hook install --pre-commit',
+        });
+    }
     if (options.format === 'json') {
+        result.governanceGaps = gaps;
         console.log(JSON.stringify(result, null, 2));
     }
     else {
         console.log(`Bootstrap complete. ${warnings} warning${warnings === 1 ? '' : 's'}.`);
+        if (gaps.length > 0) {
+            console.log('');
+            console.log('Governance gaps (configured but not enforced):');
+            for (const { gap, fix } of gaps) {
+                console.log(`  ⚠ ${gap}`);
+                console.log(`    → ${fix}`);
+            }
+        }
         console.log('');
         console.log('Next steps:');
         result.nextSteps.forEach((step, i) => {
@@ -384,74 +480,109 @@ function runSetupPhase(options, selectedPreset, detection, contexts, ciTarget, p
 // ============================================================================
 // Phase 3: ADF Init
 // ============================================================================
-function writeAdfScaffolds(aiDir, preset) {
-    fs.mkdirSync(aiDir, { recursive: true });
-    fs.writeFileSync(path.join(aiDir, 'manifest.adf'), (0, adf_2.manifestForPreset)(preset));
-    fs.writeFileSync(path.join(aiDir, 'core.adf'), adf_2.CORE_SCAFFOLD);
-    fs.writeFileSync(path.join(aiDir, 'state.adf'), adf_2.STATE_SCAFFOLD);
-    const files = ['.ai/manifest.adf', '.ai/core.adf', '.ai/state.adf'];
+function getAdfScaffolds(preset) {
+    const scaffolds = [
+        { name: 'manifest.adf', content: (0, adf_2.manifestForPreset)(preset) },
+        { name: 'core.adf', content: adf_2.CORE_SCAFFOLD },
+        { name: 'state.adf', content: adf_2.STATE_SCAFFOLD },
+    ];
     if (preset === 'docs') {
-        fs.writeFileSync(path.join(aiDir, 'content.adf'), adf_2.CONTENT_SCAFFOLD);
-        fs.writeFileSync(path.join(aiDir, 'decisions.adf'), adf_2.DECISIONS_SCAFFOLD);
-        fs.writeFileSync(path.join(aiDir, 'planning.adf'), adf_2.PLANNING_SCAFFOLD);
-        files.push('.ai/content.adf', '.ai/decisions.adf', '.ai/planning.adf');
+        scaffolds.push({ name: 'content.adf', content: adf_2.CONTENT_SCAFFOLD }, { name: 'decisions.adf', content: adf_2.DECISIONS_SCAFFOLD }, { name: 'planning.adf', content: adf_2.PLANNING_SCAFFOLD });
     }
     else if (preset === 'frontend') {
-        fs.writeFileSync(path.join(aiDir, 'frontend.adf'), adf_2.FRONTEND_SCAFFOLD);
-        files.push('.ai/frontend.adf');
+        scaffolds.push({ name: 'frontend.adf', content: adf_2.FRONTEND_SCAFFOLD });
     }
     else if (preset === 'backend' || preset === 'worker') {
-        fs.writeFileSync(path.join(aiDir, 'backend.adf'), adf_2.BACKEND_SCAFFOLD);
-        files.push('.ai/backend.adf');
+        scaffolds.push({ name: 'backend.adf', content: adf_2.BACKEND_SCAFFOLD });
     }
     else {
-        // fullstack or undefined — both frontend + backend
-        fs.writeFileSync(path.join(aiDir, 'frontend.adf'), adf_2.FRONTEND_SCAFFOLD);
-        fs.writeFileSync(path.join(aiDir, 'backend.adf'), adf_2.BACKEND_SCAFFOLD);
-        files.push('.ai/frontend.adf', '.ai/backend.adf');
+        scaffolds.push({ name: 'frontend.adf', content: adf_2.FRONTEND_SCAFFOLD }, { name: 'backend.adf', content: adf_2.BACKEND_SCAFFOLD });
     }
-    return files;
+    return scaffolds;
+}
+function buildAdfLockContent(aiDir) {
+    const lockData = {};
+    for (const mod of ['core.adf', 'state.adf']) {
+        const modPath = path.join(aiDir, mod);
+        if (!fs.existsSync(modPath))
+            continue;
+        lockData[mod] = hashContent(fs.readFileSync(modPath, 'utf-8'));
+    }
+    return JSON.stringify(lockData, null, 2) + '\n';
+}
+function writeAdfScaffolds(aiDir, force, preset) {
+    fs.mkdirSync(aiDir, { recursive: true });
+    const files = [];
+    const warnings = [];
+    let backedUp = 0;
+    let backupDir;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    for (const scaffold of getAdfScaffolds(preset)) {
+        const targetPath = path.join(aiDir, scaffold.name);
+        const label = `.ai/${scaffold.name}`;
+        if (!fs.existsSync(targetPath)) {
+            fs.writeFileSync(targetPath, scaffold.content);
+            files.push(label);
+            continue;
+        }
+        const existing = fs.readFileSync(targetPath, 'utf-8');
+        if (existing.trim() === scaffold.content.trim()) {
+            continue;
+        }
+        const byteCount = Buffer.byteLength(existing, 'utf-8');
+        if (!force) {
+            warnings.push(`${label} has custom content (${byteCount} bytes); skipping scaffold overwrite`);
+            continue;
+        }
+        backupDir ||= path.join(aiDir, '.backup');
+        fs.mkdirSync(backupDir, { recursive: true });
+        const backupName = `${scaffold.name}.${timestamp}`;
+        fs.copyFileSync(targetPath, path.join(backupDir, backupName));
+        warnings.push(`Backed up ${label} (${byteCount} bytes) → .ai/.backup/${backupName}`);
+        backedUp++;
+        fs.writeFileSync(targetPath, scaffold.content);
+        files.push(label);
+    }
+    const lockPath = path.join(aiDir, '.adf.lock');
+    const lockContent = buildAdfLockContent(aiDir);
+    if (!fs.existsSync(lockPath) || fs.readFileSync(lockPath, 'utf-8') !== lockContent) {
+        fs.writeFileSync(lockPath, lockContent);
+        files.push('.ai/.adf.lock');
+    }
+    return { files, warnings, backedUp };
 }
 function runAdfInitPhase(options, force, preset) {
     const warnings = [];
     const files = [];
     const pointers = [];
+    const detectedOrphans = [];
     try {
         const aiDir = '.ai';
-        const manifestPath = path.join(aiDir, 'manifest.adf');
-        // Create .ai/ scaffolds
-        const alreadyExists = fs.existsSync(manifestPath);
-        const hasCustomContent = alreadyExists && hasCustomAdfContent(aiDir);
-        if (!alreadyExists) {
-            // Greenfield: write scaffolds (preset-aware on-demand modules)
-            files.push(...writeAdfScaffolds(aiDir, preset));
-            // Write .adf.lock
-            const lockData = {};
-            for (const mod of ['core.adf', 'state.adf']) {
-                const content = fs.readFileSync(path.join(aiDir, mod), 'utf-8');
-                lockData[mod] = hashContent(content);
+        const scaffoldResult = writeAdfScaffolds(aiDir, force, preset);
+        files.push(...scaffoldResult.files);
+        warnings.push(...scaffoldResult.warnings);
+        // Detect orphaned ADF modules not registered in manifest (#65)
+        const manifestPath2 = path.join(aiDir, 'manifest.adf');
+        if (fs.existsSync(manifestPath2)) {
+            try {
+                const manifestContent = fs.readFileSync(manifestPath2, 'utf-8');
+                const allAdfFiles = fs.readdirSync(aiDir).filter(f => f.endsWith('.adf') && f !== 'manifest.adf');
+                const doc = (0, adf_3.parseAdf)(manifestContent);
+                const manifest = (0, adf_3.parseManifest)(doc);
+                const registeredModules = new Set([
+                    ...manifest.defaultLoad,
+                    ...manifest.onDemand.map(m => m.path),
+                ]);
+                const orphans = allAdfFiles.filter(f => !registeredModules.has(f));
+                if (orphans.length > 0) {
+                    detectedOrphans.push(...orphans);
+                    warnings.push(`Found ${orphans.length} unregistered .adf module(s): ${orphans.join(', ')}`);
+                    warnings.push('Run `charter adf register` to add them to the manifest.');
+                }
             }
-            fs.writeFileSync(path.join(aiDir, '.adf.lock'), JSON.stringify(lockData, null, 2) + '\n');
-            files.push('.ai/.adf.lock');
-        }
-        else if (hasCustomContent && !force) {
-            // Custom ADF content exists — don't overwrite, suggest migrate
-            warnings.push('.ai/ contains custom ADF content; skipping scaffold overwrite');
-            warnings.push("Run 'charter adf migrate' to consolidate agent configs into ADF");
-        }
-        else if (force) {
-            // Force overwrite (preset-aware on-demand modules)
-            files.push(...writeAdfScaffolds(aiDir, preset));
-            const lockData = {};
-            for (const mod of ['core.adf', 'state.adf']) {
-                const content = fs.readFileSync(path.join(aiDir, mod), 'utf-8');
-                lockData[mod] = hashContent(content);
+            catch {
+                // Non-critical — manifest parse failure shouldn't block bootstrap
             }
-            fs.writeFileSync(path.join(aiDir, '.adf.lock'), JSON.stringify(lockData, null, 2) + '\n');
-            files.push('.ai/.adf.lock');
-        }
-        else {
-            warnings.push('.ai/ already exists; skipping scaffold (use --yes to overwrite)');
         }
         // Generate pointer files (CLAUDE.md uses hybrid template with module index)
         const pointerFiles = [
@@ -468,16 +599,16 @@ function runAdfInitPhase(options, force, preset) {
                 fs.writeFileSync(pointerPath, pf.content);
                 pointers.push(pf.label);
             }
-            else if (exists && !isAlreadyThinPointer(pointerPath)) {
-                // File has custom content — don't overwrite, suggest migrate
-                warnings.push(`${pf.name} has custom content; skipping pointer (use 'charter adf migrate' first)`);
-            }
             else if (force) {
                 fs.writeFileSync(pointerPath, pf.content);
                 pointers.push(pf.label);
             }
+            else if (!isAlreadyThinPointer(pointerPath)) {
+                // File has custom content — don't overwrite, suggest migrate
+                warnings.push(`${pf.name} has custom content; skipping pointer (run 'charter adf migrate' first or use --force to overwrite)`);
+            }
             else {
-                warnings.push(`${pf.name} already exists; skipping (use --yes to overwrite)`);
+                warnings.push(`${pf.name} already exists; skipping (use --force to overwrite)`);
             }
         }
         // Populate module index in CLAUDE.md from manifest
@@ -486,7 +617,7 @@ function runAdfInitPhase(options, force, preset) {
             step: {
                 name: 'adf-init',
                 status: 'pass',
-                details: { files, pointers },
+                details: { files, pointers, backedUp: scaffoldResult.backedUp, orphans: detectedOrphans },
                 warnings,
             },
         };
@@ -498,7 +629,7 @@ function runAdfInitPhase(options, force, preset) {
             step: {
                 name: 'adf-init',
                 status: 'fail',
-                details: { files, pointers, error: msg },
+                details: { files, pointers, orphans: detectedOrphans, error: msg },
                 warnings,
             },
         };
@@ -643,7 +774,48 @@ function detectPackageManagerFromLockfiles() {
     return 'npm';
 }
 // ============================================================================
-// Phase 6: Doctor
+// Phase 6: Populate (#89)
+// ============================================================================
+async function runPopulatePhase(options) {
+    const warnings = [];
+    const aiDir = '.ai';
+    if (!fs.existsSync(path.join(aiDir, 'manifest.adf'))) {
+        return {
+            step: {
+                name: 'populate',
+                status: 'skip',
+                details: { populated: 0, skipped: 0, reason: 'no manifest.adf' },
+                warnings,
+            },
+        };
+    }
+    try {
+        const { adfPopulateCommand } = require('./adf-populate');
+        const code = await adfPopulateCommand(options, ['--force']);
+        return {
+            step: {
+                name: 'populate',
+                status: code === 0 ? 'pass' : 'fail',
+                details: { populated: code === 0 ? 1 : 0, skipped: 0 },
+                warnings,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        warnings.push(`Populate failed (non-fatal): ${msg}`);
+        return {
+            step: {
+                name: 'populate',
+                status: 'pass', // non-fatal — bootstrap shouldn't fail on populate
+                details: { populated: 0, skipped: 0, error: msg },
+                warnings,
+            },
+        };
+    }
+}
+// ============================================================================
+// Phase 7: Doctor
 // ============================================================================
 function runDoctorPhase(options, skipDoctor) {
     const warnings = [];
@@ -754,32 +926,59 @@ function hashContent(content) {
     return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
 }
 /**
- * Check if .ai/core.adf has content beyond the scaffold template.
+ * Check if a file is already a thin ADF pointer.
  */
-function hasCustomAdfContent(aiDir) {
-    const coreAdfPath = path.join(aiDir, 'core.adf');
-    if (!fs.existsSync(coreAdfPath))
-        return false;
+function isAlreadyThinPointer(filePath) {
     try {
-        const content = fs.readFileSync(coreAdfPath, 'utf-8');
-        // Check if the file has been modified from default scaffold
-        // A custom file will have different content than the CORE_SCAFFOLD
-        return content.trim() !== adf_2.CORE_SCAFFOLD.trim();
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return adf_1.POINTER_MARKERS.some(marker => content.includes(marker));
     }
     catch {
         return false;
     }
 }
 /**
- * Check if a file is already a thin ADF pointer.
+ * Prompt user for a yes/no answer via readline.
  */
-function isAlreadyThinPointer(filePath) {
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return adf_1.POINTER_MARKERS.some(marker => content.includes(marker));
+function promptYesNo(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+/**
+ * Append orphaned modules to the ON_DEMAND section of manifest.adf.
+ */
+function registerOrphansInManifest(manifestPath, orphans) {
+    const content = fs.readFileSync(manifestPath, 'utf-8');
+    const lines = content.split('\n');
+    // Find ON_DEMAND section
+    const onDemandIdx = lines.findIndex(l => l.includes('ON_DEMAND:'));
+    if (onDemandIdx === -1) {
+        // No ON_DEMAND section — append one
+        const newEntries = orphans.map(name => {
+            const stem = name.replace('.adf', '');
+            return `  - ${name} (Triggers on: ${stem})`;
+        });
+        fs.writeFileSync(manifestPath, content.trimEnd() + '\n\n📂 ON_DEMAND:\n' + newEntries.join('\n') + '\n');
+        return;
     }
-    catch {
-        return false;
+    // Find end of ON_DEMAND entries
+    let insertIdx = onDemandIdx + 1;
+    while (insertIdx < lines.length && lines[insertIdx].match(/^\s+-\s/)) {
+        insertIdx++;
     }
+    const newEntries = orphans.map(name => {
+        const stem = name.replace('.adf', '');
+        return `  - ${name} (Triggers on: ${stem})`;
+    });
+    lines.splice(insertIdx, 0, ...newEntries);
+    fs.writeFileSync(manifestPath, lines.join('\n'));
 }
 //# sourceMappingURL=bootstrap.js.map