brainclaw 0.19.6 → 0.19.10

package/dist/core/bootstrap.js

@@ -3,27 +3,60 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { JsonStore } from './json-store.js';
 import { generateId, nowISO } from './ids.js';
-import { resolveEntityDir } from './io.js';
-import { BootstrapProfileDocumentSchema, MemorySeedDocumentSchema, } from './schema.js';
+import { memoryPath, resolveEntityDir, withStoreLock, writeFileAtomic } from './io.js';
+import { BootstrapApplicationReceiptSchema, BootstrapInterviewPlanSchema, BootstrapInterviewQuestionSchema, BootstrapImportPlanDocumentSchema, BootstrapProfileDocumentSchema, BootstrapSuggestionDocumentSchema, MemorySeedDocumentSchema, } from './schema.js';
 import { loadVersionedJsonFile, saveVersionedJsonFile } from './migration.js';
 import { analyzeRepository } from './repo-analysis.js';
 import { buildExecutionContext, compactExecutionContext } from './execution-context.js';
 import { buildAgentToolingContext } from './agent-context.js';
+import { createInstruction, loadInstructions, saveInstruction } from './instructions.js';
+import { resolveCurrentAgentName } from './agent-registry.js';
+import { loadState } from './state.js';
+import { generateMarkdown } from './markdown.js';
 const README_CANDIDATES = ['README.md', 'README', 'README.txt', 'README.mdx'];
 const DOC_HINTS = ['docs', 'doc'];
 const MAKEFILE_NAME = 'Makefile';
 const PROFILE_FILE = 'profile.json';
+const IMPORT_PLAN_FILE = 'import-plan.json';
+const APPLICATION_FILE = 'last-application.json';
 const HOTSPOT_LIMIT = 3;
 const DERIVED_SCHEMA_VERSION = 2;
+const EMPTY_WORKSPACE_IGNORED = new Set([
+    '.git',
+    '.brainclaw',
+    '.gitignore',
+    '.gitattributes',
+    '.gitmodules',
+    '.DS_Store',
+    'Thumbs.db',
+    'internal-docs',
+]);
+const NATIVE_INSTRUCTION_FILES = [
+    'AGENTS.md',
+    'CLAUDE.md',
+    'GEMINI.md',
+    '.windsurfrules',
+    '.github/copilot-instructions.md',
+];
+const NATIVE_INSTRUCTION_DIRS = [
+    '.cursor/rules',
+    '.roo/rules',
+    '.continue/rules',
+    '.clinerules',
+];
 export function runBootstrapProfile(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const target = normalizeTarget(options.target);
     const existing = loadBootstrapProfile(cwd);
+    const existingPlan = loadBootstrapImportPlan(cwd);
+    const lastApplication = loadBootstrapApplication(cwd);
     const existingFingerprint = currentRepoFingerprint(cwd);
-    if (!options.refresh && existing && isProfileReusable(existing, target, existingFingerprint)) {
+    if (!options.refresh && existing && existingPlan && isProfileReusable(existing, target, existingFingerprint)) {
         return {
             profile: existing,
             seeds: listBootstrapSeeds(cwd),
+            importPlan: existingPlan,
+            lastApplication,
             reusedProfile: true,
         };
     }
@@ -32,6 +65,8 @@ export function runBootstrapProfile(options = {}) {
     return {
         profile: artifacts.profile,
         seeds: artifacts.seeds,
+        importPlan: artifacts.importPlan,
+        lastApplication,
         reusedProfile: false,
     };
 }
@@ -82,8 +117,21 @@ export function selectDerivedSignals(target, maxSignals, cwd) {
 }
 export function renderBootstrapSummary(result) {
     const lines = [result.profile.summary];
+    if (result.profile.workspace_kind) {
+        lines.push(`Workspace kind: ${result.profile.workspace_kind}`);
+    }
+    if (result.profile.confidence) {
+        lines.push(`Confidence: ${result.profile.confidence}`);
+    }
     lines.push(`Sources scanned: ${result.profile.sources_scanned.join(', ') || 'none'}`);
     lines.push(`Seed count: ${result.profile.seed_count}`);
+    if ((result.profile.native_instruction_files?.length ?? 0) > 0) {
+        lines.push(`Native instruction files: ${result.profile.native_instruction_files.join(', ')}`);
+    }
+    if ((result.profile.gaps?.length ?? 0) > 0) {
+        lines.push(`Open gaps: ${result.profile.gaps.join(' | ')}`);
+    }
+    lines.push(`Import suggestions: ${result.importPlan.suggestion_count}`);
     if (result.profile.repo_fingerprint) {
         lines.push(`Repo fingerprint: ${result.profile.repo_fingerprint}`);
     }
@@ -93,6 +141,24 @@ export function renderBootstrapSummary(result) {
     if (result.reusedProfile) {
         lines.push('Reused existing bootstrap profile.');
     }
+    if (result.lastApplication && !result.lastApplication.uninstalled_at) {
+        lines.push(`Last bootstrap import: ${result.lastApplication.managed_artifacts.length} managed artifact(s) from ${result.lastApplication.applied_at}`);
+    }
+    if (result.importPlan.suggestions.length > 0) {
+        lines.push('');
+        lines.push('Import proposal:');
+        for (const suggestion of result.importPlan.suggestions.slice(0, 10)) {
+            const scope = suggestion.scope ? `:${suggestion.scope}` : '';
+            lines.push(`- [${suggestion.target}/${suggestion.confidence}] <${suggestion.layer ?? 'global'}${scope}> ${suggestion.text}`);
+        }
+    }
+    if ((result.importPlan.interview?.question_count ?? 0) > 0) {
+        lines.push('');
+        lines.push('Adaptive interview:');
+        for (const question of result.importPlan.interview.questions.slice(0, 6)) {
+            lines.push(`- [${question.priority}/${question.audience}] ${question.prompt}`);
+        }
+    }
     if (result.seeds.length > 0) {
         lines.push('');
         lines.push('Derived signals:');
@@ -102,9 +168,29 @@ export function renderBootstrapSummary(result) {
     }
     return lines.join('\n');
 }
+export function renderBootstrapInterview(result, audience = 'any') {
+    const interview = result.importPlan.interview;
+    if (!interview || interview.question_count === 0) {
+        return 'No adaptive interview questions are needed right now.';
+    }
+    const questions = interview.questions.filter((question) => audience === 'any' || question.audience === 'any' || question.audience === audience);
+    if (questions.length === 0) {
+        return `No adaptive interview questions are targeted to ${audience}.`;
+    }
+    const lines = [interview.summary, `Audience: ${audience}`];
+    lines.push('');
+    for (const [index, question] of questions.entries()) {
+        lines.push(`${index + 1}. ${question.prompt}`);
+        lines.push(`   Why: ${question.rationale}`);
+        lines.push(`   Expected answer: ${question.response_kind}`);
+    }
+    return lines.join('\n');
+}
 function buildBootstrapArtifacts(input) {
     const sourcesScanned = [];
     const seeds = [];
+    const workspace = classifyWorkspace(input.cwd);
+    const nativeInstructionFiles = discoverNativeInstructionFiles(input.cwd);
     const readmePath = findFirstExisting(input.cwd, README_CANDIDATES);
     if (readmePath) {
         sourcesScanned.push('README');
@@ -116,6 +202,10 @@ function buildBootstrapArtifacts(input) {
         sourcesScanned.push('AGENTS.md');
         seeds.push(...extractAgentsSeeds(agentsPath, input.target));
     }
+    if (nativeInstructionFiles.length > 0) {
+        sourcesScanned.push('native_instructions');
+        seeds.push(...extractNativeInstructionSeeds(nativeInstructionFiles.map((relativePath) => path.join(input.cwd, relativePath)), input.cwd, input.target));
+    }
     const manifestResult = extractManifestSeeds(input.cwd, input.target);
     if (manifestResult.seeds.length > 0) {
         sourcesScanned.push(...manifestResult.sources);
@@ -142,12 +232,37 @@ function buildBootstrapArtifacts(input) {
         seeds.push(...gitProbe.hotspotSeeds);
     }
     const uniqueSeeds = dedupeSeeds(seeds);
+    const confidence = inferBootstrapConfidence({
+        workspaceKind: workspace.kind,
+        readmePresent: Boolean(readmePath),
+        agentsPresent,
+        nativeInstructionFiles,
+        seedCount: uniqueSeeds.length,
+    });
+    const gaps = inferBootstrapGaps({
+        workspaceKind: workspace.kind,
+        readmePresent: Boolean(readmePath),
+        nativeInstructionFiles,
+        seedCount: uniqueSeeds.length,
+    });
     const summary = buildSummary({
+        workspaceKind: workspace.kind,
         agentsPresent,
+        nativeInstructionFiles,
         gitAvailable: gitProbe.available,
         repoAnalysis,
         seeds: uniqueSeeds,
         target: input.target,
+        confidence,
+        gaps,
+    });
+    const importPlan = buildBootstrapImportPlan({
+        cwd: input.cwd,
+        target: input.target,
+        workspaceKind: workspace.kind,
+        confidence,
+        gaps,
+        seeds: uniqueSeeds,
     });
     return {
         profile: BootstrapProfileDocumentSchema.parse({
@@ -160,11 +275,16 @@ function buildBootstrapArtifacts(input) {
             agents_md_present: agentsPresent,
             seed_count: uniqueSeeds.length,
             target: input.target,
+            workspace_kind: workspace.kind,
+            confidence,
+            native_instruction_files: nativeInstructionFiles,
+            gaps,
         }),
         seeds: uniqueSeeds.map((seed) => MemorySeedDocumentSchema.parse({
             ...seed,
             schema_version: DERIVED_SCHEMA_VERSION,
         })),
+        importPlan,
     };
 }
 function extractReadmeSeeds(filepath, target) {
@@ -236,6 +356,80 @@ function extractAgentsSeeds(filepath, target) {
     }
     return seeds;
 }
+export function loadBootstrapImportPlan(cwd) {
+    const filepath = bootstrapImportPlanPath(cwd);
+    if (!fs.existsSync(filepath)) {
+        return undefined;
+    }
+    try {
+        return loadVersionedJsonFile('bootstrap_import_plan', filepath).document;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function loadBootstrapApplication(cwd) {
+    const filepath = bootstrapApplicationPath(cwd);
+    if (!fs.existsSync(filepath)) {
+        return undefined;
+    }
+    try {
+        return loadVersionedJsonFile('bootstrap_application', filepath).document;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractNativeInstructionSeeds(filepaths, cwd, target) {
+    const seeds = [];
+    for (const filepath of filepaths) {
+        if (path.basename(filepath) === 'AGENTS.md') {
+            continue;
+        }
+        const relativePath = path.relative(cwd, filepath).replace(/\\/g, '/');
+        const raw = fs.readFileSync(filepath, 'utf-8');
+        const lines = raw.split(/\r?\n/);
+        const heading = lines.find((line) => line.trim().startsWith('#'));
+        const firstContent = lines.find((line) => line.trim().length > 0);
+        const label = heading
+            ? heading.replace(/^#+\s*/, '').trim()
+            : firstContent?.trim().replace(/^[-*]\s+/, '') ?? relativePath;
+        seeds.push(createSeed({
+            text: `Native agent guidance from ${path.basename(relativePath)}: ${label}`,
+            seedKind: 'agent_rule',
+            sourceKind: 'native_instruction',
+            sourceRef: relativePath,
+            confidence: 'high',
+            tags: ['bootstrap', 'agent', 'native-context'],
+            relatedPaths: target ? [target] : undefined,
+        }));
+        let extracted = 0;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!/^([-*]|\d+\.)\s+/.test(trimmed)) {
+                continue;
+            }
+            const text = trimmed.replace(/^([-*]|\d+\.)\s+/, '').trim();
+            if (!text) {
+                continue;
+            }
+            seeds.push(createSeed({
+                text,
+                seedKind: 'agent_rule',
+                sourceKind: 'native_instruction',
+                sourceRef: relativePath,
+                confidence: 'medium',
+                tags: ['bootstrap', 'agent', 'native-context'],
+                relatedPaths: target ? [target] : undefined,
+            }));
+            extracted++;
+            if (extracted >= 5) {
+                break;
+            }
+        }
+    }
+    return seeds;
+}
 function extractManifestSeeds(cwd, target) {
     const sources = [];
     const seeds = [];
@@ -468,6 +662,7 @@ function probeGit(cwd, target) {
 function persistBootstrapArtifacts(artifacts, cwd) {
     ensureBootstrapDirs(cwd);
     saveVersionedJsonFile('bootstrap_profile', bootstrapProfilePath(cwd), artifacts.profile);
+    saveVersionedJsonFile('bootstrap_import_plan', bootstrapImportPlanPath(cwd), artifacts.importPlan);
     const store = bootstrapSeedStore(cwd);
     const existingIds = new Set(store.list().map((seed) => seed.id));
     for (const seed of artifacts.seeds) {
@@ -502,6 +697,12 @@ function bootstrapSeedsDir(cwd) {
 function bootstrapProfilePath(cwd) {
     return path.join(bootstrapDir(cwd), PROFILE_FILE);
 }
+function bootstrapImportPlanPath(cwd) {
+    return path.join(bootstrapDir(cwd), IMPORT_PLAN_FILE);
+}
+function bootstrapApplicationPath(cwd) {
+    return path.join(bootstrapDir(cwd), APPLICATION_FILE);
+}
 function isProfileReusable(profile, target, currentFingerprint) {
     if ((profile.target ?? undefined) !== target) {
         return false;
@@ -546,11 +747,15 @@ function dedupeSeeds(seeds) {
 }
 function buildSummary(input) {
     const parts = [];
-    parts.push(`Bootstrap summary${input.target ? ` for ${input.target}` : ''}: ${input.seeds.length} derived signal(s).`);
+    parts.push(`Bootstrap summary${input.target ? ` for ${input.target}` : ''}: ${input.workspaceKind} workspace, ${input.seeds.length} derived signal(s).`);
+    parts.push(`Confidence: ${input.confidence}.`);
     parts.push(`Repository mode looks ${input.repoAnalysis.recommendedMode}.`);
     if (input.agentsPresent) {
         parts.push('AGENTS.md detected and summarized.');
     }
+    if (input.nativeInstructionFiles.length > 0) {
+        parts.push(`${input.nativeInstructionFiles.length} native instruction file(s) detected.`);
+    }
     if (input.gitAvailable) {
         parts.push('Git history available for hotspot detection.');
     }
@@ -558,8 +763,386 @@ function buildSummary(input) {
     if (commandCount > 0) {
         parts.push(`${commandCount} command-oriented hint(s) found.`);
     }
+    if (input.gaps.length > 0) {
+        parts.push(`Needs follow-up on: ${input.gaps.join('; ')}.`);
+    }
     return parts.join(' ');
 }
+function buildBootstrapImportPlan(input) {
+    const activeInstructionKeys = new Set(loadInstructions(input.cwd)
+        .filter((entry) => entry.active)
+        .map((entry) => instructionIdentityKey(entry.text, entry.layer, entry.scope)));
+    const suggestions = [];
+    const seenSuggestionKeys = new Set();
+    const importedSources = new Set();
+    const groupedBySource = new Map();
+    for (const seed of input.seeds) {
+        const bucket = groupedBySource.get(seed.source_ref) ?? [];
+        bucket.push(seed);
+        groupedBySource.set(seed.source_ref, bucket);
+    }
+    for (const seed of input.seeds) {
+        const suggestion = seedToBootstrapSuggestion(seed, false);
+        if (!suggestion) {
+            continue;
+        }
+        const suggestionKey = suggestionIdentityKey(suggestion);
+        if (seenSuggestionKeys.has(suggestionKey) || activeInstructionKeys.has(suggestionKey)) {
+            continue;
+        }
+        seenSuggestionKeys.add(suggestionKey);
+        importedSources.add(seed.source_ref);
+        suggestions.push(BootstrapSuggestionDocumentSchema.parse({
+            ...suggestion,
+            schema_version: DERIVED_SCHEMA_VERSION,
+        }));
+    }
+    for (const [sourceRef, seeds] of groupedBySource.entries()) {
+        if (importedSources.has(sourceRef)) {
+            continue;
+        }
+        const summarySeed = seeds.find((seed) => isBootstrapSummarySeed(seed.text));
+        if (!summarySeed) {
+            continue;
+        }
+        const suggestion = seedToBootstrapSuggestion(summarySeed, true);
+        if (!suggestion) {
+            continue;
+        }
+        const suggestionKey = suggestionIdentityKey(suggestion);
+        if (seenSuggestionKeys.has(suggestionKey) || activeInstructionKeys.has(suggestionKey)) {
+            continue;
+        }
+        seenSuggestionKeys.add(suggestionKey);
+        suggestions.push(BootstrapSuggestionDocumentSchema.parse({
+            ...suggestion,
+            schema_version: DERIVED_SCHEMA_VERSION,
+        }));
+    }
+    const summary = suggestions.length === 0
+        ? 'No safe bootstrap imports are ready yet; review the gaps and use an interview/import step before promoting derived context.'
+        : `${suggestions.length} bootstrap instruction suggestion(s) are ready to import after review.`;
+    const interview = buildBootstrapInterviewPlan({
+        workspaceKind: input.workspaceKind,
+        gaps: input.gaps,
+        confidence: input.confidence,
+        nativeInstructionSources: [...new Set(input.seeds
+                .filter((seed) => seed.source_kind === 'native_instruction')
+                .map((seed) => seed.source_ref))],
+    });
+    return BootstrapImportPlanDocumentSchema.parse({
+        schema_version: DERIVED_SCHEMA_VERSION,
+        derived_at: nowISO(),
+        target: input.target,
+        workspace_kind: input.workspaceKind,
+        confidence: input.confidence,
+        summary,
+        requires_confirmation: true,
+        gaps: input.gaps,
+        suggestion_count: suggestions.length,
+        suggestions,
+        interview,
+    });
+}
+function buildBootstrapInterviewPlan(input) {
+    const questions = [];
+    const add = (prompt, rationale, priority, audience, responseKind, gapKeys) => {
+        questions.push(BootstrapInterviewQuestionSchema.parse({
+            id: generateId('bootstrap_suggestions'),
+            prompt,
+            rationale,
+            priority,
+            audience,
+            response_kind: responseKind,
+            gap_keys: gapKeys,
+        }));
+    };
+    if (input.workspaceKind === 'empty') {
+        add('What is this workspace trying to build in one sentence?', 'An empty workspace needs a product intent anchor before Brainclaw can create durable guidance.', 'high', 'any', 'short_text', ['project intent is not documented yet']);
+        add('Which coding agents do you expect to use here, and should they work mostly sequentially or in parallel later?', 'Bootstrap should capture collaboration expectations early, especially before worktree isolation exists.', 'high', 'any', 'list', ['agent workflow expectations should be captured explicitly']);
+        add('For a CLI-only agent, what should the very first safe action be after reading context?', 'Pure CLI agents need an explicit first action because they do not benefit from rich IDE affordances.', 'medium', 'cli', 'short_text', ['agent workflow expectations should be captured explicitly']);
+        add('For an IDE chat agent, what should it ask or inspect before editing code?', 'IDE chat agents can ask targeted follow-up questions; capturing that expectation avoids drift between surfaces.', 'medium', 'ide_chat', 'short_text', ['agent workflow expectations should be captured explicitly']);
+    }
+    if (input.gaps.includes('no README-level project overview detected')) {
+        add('What is the current purpose of this existing project, and what would you want a new agent to understand first?', 'When README context is missing, Brainclaw needs an explicit project overview to avoid weak brownfield inference.', 'high', 'any', 'long_text', ['no README-level project overview detected']);
+    }
+    if (input.gaps.includes('no native agent instruction files detected')) {
+        add('Should Brainclaw treat this project as agent-guided even though no native agent instruction files were found?', 'This determines whether Brainclaw should synthesize workflow guidance or stay memory-only for now.', 'medium', 'any', 'boolean', ['no native agent instruction files detected']);
+    }
+    if (input.gaps.includes('derived context is sparse and may need an interview')) {
+        add('Which constraints or conventions are important enough that every future agent should see them immediately?', 'Sparse derived context should be turned into a small set of high-signal shared instructions or constraints.', 'high', 'any', 'list', ['derived context is sparse and may need an interview']);
+    }
+    if (input.nativeInstructionSources.length > 0) {
+        add(`Which parts of ${input.nativeInstructionSources.join(', ')} should become durable Brainclaw memory, and which parts should remain local agent guidance only?`, 'Native agent files are derived context first; Brainclaw needs a selective import decision instead of silently promoting them.', 'medium', 'ide_chat', 'long_text', ['native instruction import boundary']);
+    }
+    if (questions.length === 0 && input.confidence !== 'high') {
+        add('What is still ambiguous enough that a future agent would likely ask you before proceeding?', 'Fallback question when bootstrap confidence is not high but no specific gap generated a dedicated prompt.', 'medium', 'any', 'long_text', ['confidence fallback']);
+    }
+    const summary = questions.length === 0
+        ? 'No adaptive interview questions are needed right now.'
+        : `${questions.length} adaptive interview question(s) are ready to turn bootstrap gaps into confirmed shared memory.`;
+    return BootstrapInterviewPlanSchema.parse({
+        schema_version: DERIVED_SCHEMA_VERSION,
+        derived_at: nowISO(),
+        workspace_kind: input.workspaceKind,
+        audience: 'any',
+        summary,
+        question_count: questions.length,
+        questions,
+    });
+}
+function seedToBootstrapSuggestion(seed, allowSummaryFallback) {
+    if (seed.seed_kind !== 'agent_rule' && seed.seed_kind !== 'command') {
+        return undefined;
+    }
+    if (seed.seed_kind === 'agent_rule' && isBootstrapSummarySeed(seed.text) && !allowSummaryFallback) {
+        return undefined;
+    }
+    const target = inferBootstrapInstructionTarget(seed);
+    if (!target) {
+        return undefined;
+    }
+    return {
+        id: generateId('bootstrap_suggestions'),
+        target: 'instruction',
+        text: seed.text,
+        rationale: renderBootstrapSuggestionRationale(seed),
+        confidence: seed.confidence,
+        source_seed_ids: [seed.id],
+        source_refs: [seed.source_ref],
+        layer: target.layer,
+        scope: target.scope,
+        tags: normalizeBootstrapSuggestionTags(seed.tags),
+        related_paths: seed.related_paths,
+        reversible: true,
+    };
+}
+function inferBootstrapInstructionTarget(seed) {
+    if (seed.source_kind === 'agents_md') {
+        return { layer: 'global' };
+    }
+    if (seed.seed_kind === 'command') {
+        return { layer: 'global' };
+    }
+    if (seed.source_kind !== 'native_instruction') {
+        return { layer: 'global' };
+    }
+    const ref = seed.source_ref.replace(/\\/g, '/');
+    if (ref === 'CLAUDE.md')
+        return { layer: 'agent', scope: 'claude-code' };
+    if (ref === 'GEMINI.md')
+        return { layer: 'agent', scope: 'antigravity' };
+    if (ref === '.windsurfrules')
+        return { layer: 'agent', scope: 'windsurf' };
+    if (ref === '.github/copilot-instructions.md')
+        return { layer: 'agent', scope: 'github-copilot' };
+    if (ref.startsWith('.cursor/rules/'))
+        return { layer: 'agent', scope: 'cursor' };
+    if (ref.startsWith('.roo/rules/'))
+        return { layer: 'agent', scope: 'roo' };
+    if (ref.startsWith('.continue/rules/'))
+        return { layer: 'agent', scope: 'continue' };
+    if (ref.startsWith('.clinerules/'))
+        return { layer: 'agent', scope: 'cline' };
+    return { layer: 'global' };
+}
+function renderBootstrapSuggestionRationale(seed) {
+    switch (seed.source_kind) {
+        case 'agents_md':
+            return 'Derived from AGENTS.md';
+        case 'native_instruction':
+            return `Derived from native agent instruction file ${seed.source_ref}`;
+        case 'readme':
+            return `Derived from ${seed.source_ref}`;
+        case 'manifest':
+            return `Derived from ${seed.source_ref}`;
+        default:
+            return `Derived from ${seed.source_ref}`;
+    }
+}
+function normalizeBootstrapSuggestionTags(tags) {
+    const normalized = tags.filter((tag) => tag !== 'bootstrap' && tag !== 'native-context');
+    normalized.push('bootstrap-import');
+    return [...new Set(normalized)];
+}
+function isBootstrapSummarySeed(text) {
+    return text.startsWith('Agent guide: ') || text.startsWith('Native agent guidance from ');
+}
+function suggestionIdentityKey(suggestion) {
+    return instructionIdentityKey(suggestion.text, suggestion.layer ?? 'global', suggestion.scope);
+}
+function instructionIdentityKey(text, layer, scope) {
+    return `${layer}:${scope ?? '*'}:${text.trim().toLowerCase()}`;
+}
+export function applyBootstrapImport(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const result = runBootstrapProfile(options);
+    const proposal = result.importPlan;
+    if (proposal.suggestions.length === 0) {
+        return {
+            proposal,
+            receipt: loadBootstrapApplication(cwd),
+            createdCount: 0,
+            skippedCount: 0,
+        };
+    }
+    const activeInstructionKeys = new Set(loadInstructions(cwd)
+        .filter((entry) => entry.active)
+        .map((entry) => instructionIdentityKey(entry.text, entry.layer, entry.scope)));
+    const managedArtifacts = [];
+    let createdCount = 0;
+    let skippedCount = 0;
+    withStoreLock(cwd, () => {
+        for (const suggestion of proposal.suggestions) {
+            if (suggestion.target !== 'instruction') {
+                skippedCount++;
+                continue;
+            }
+            const identityKey = suggestionIdentityKey(suggestion);
+            if (activeInstructionKeys.has(identityKey)) {
+                skippedCount++;
+                continue;
+            }
+            const entry = createInstruction(suggestion.text, {
+                layer: suggestion.layer ?? 'global',
+                scope: suggestion.scope,
+                tags: suggestion.tags,
+                author: resolveCurrentAgentName(cwd),
+            }, cwd);
+            activeInstructionKeys.add(identityKey);
+            managedArtifacts.push({
+                kind: 'instruction',
+                id: entry.id,
+                suggestion_id: suggestion.id,
+                rollback_action: 'deactivate',
+            });
+            createdCount++;
+        }
+        if (createdCount > 0) {
+            writeFileAtomic(memoryPath('project.md', cwd), generateMarkdown(loadState(cwd)));
+        }
+    });
+    const receipt = BootstrapApplicationReceiptSchema.parse({
+        schema_version: DERIVED_SCHEMA_VERSION,
+        applied_at: nowISO(),
+        proposal_derived_at: proposal.derived_at,
+        target: proposal.target,
+        workspace_kind: proposal.workspace_kind,
+        managed_artifacts: managedArtifacts,
+        suggestion_ids: managedArtifacts.map((artifact) => artifact.suggestion_id),
+    });
+    saveVersionedJsonFile('bootstrap_application', bootstrapApplicationPath(cwd), receipt);
+    return {
+        proposal,
+        receipt,
+        createdCount,
+        skippedCount,
+    };
+}
+export function uninstallBootstrapImport(cwd) {
+    const resolvedCwd = cwd ?? process.cwd();
+    const receipt = loadBootstrapApplication(resolvedCwd);
+    if (!receipt || receipt.uninstalled_at) {
+        return {
+            receipt,
+            deactivatedCount: 0,
+            skippedCount: 0,
+        };
+    }
+    const instructions = loadInstructions(resolvedCwd);
+    let deactivatedCount = 0;
+    let skippedCount = 0;
+    withStoreLock(resolvedCwd, () => {
+        for (const artifact of receipt.managed_artifacts) {
+            if (artifact.kind !== 'instruction') {
+                skippedCount++;
+                continue;
+            }
+            const instruction = instructions.find((entry) => entry.id === artifact.id);
+            if (!instruction || !instruction.active) {
+                skippedCount++;
+                continue;
+            }
+            instruction.active = false;
+            instruction.updated_at = nowISO();
+            saveInstruction(instruction, resolvedCwd);
+            deactivatedCount++;
+        }
+        if (deactivatedCount > 0) {
+            writeFileAtomic(memoryPath('project.md', resolvedCwd), generateMarkdown(loadState(resolvedCwd)));
+        }
+    });
+    const nextReceipt = BootstrapApplicationReceiptSchema.parse({
+        ...receipt,
+        uninstalled_at: nowISO(),
+    });
+    saveVersionedJsonFile('bootstrap_application', bootstrapApplicationPath(resolvedCwd), nextReceipt);
+    return {
+        receipt: nextReceipt,
+        deactivatedCount,
+        skippedCount,
+    };
+}
+function classifyWorkspace(cwd) {
+    const visibleEntries = fs.readdirSync(cwd)
+        .filter((entry) => !EMPTY_WORKSPACE_IGNORED.has(entry));
+    return {
+        kind: visibleEntries.length === 0 ? 'empty' : 'existing',
+        visibleEntries,
+    };
+}
+function discoverNativeInstructionFiles(cwd) {
+    const discovered = new Set();
+    for (const relativePath of NATIVE_INSTRUCTION_FILES) {
+        const filepath = path.join(cwd, relativePath);
+        if (fs.existsSync(filepath) && fs.statSync(filepath).isFile()) {
+            discovered.add(relativePath);
+        }
+    }
+    for (const relativeDir of NATIVE_INSTRUCTION_DIRS) {
+        const dir = path.join(cwd, relativeDir);
+        if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+            continue;
+        }
+        for (const entry of fs.readdirSync(dir).sort()) {
+            if (!/\.(md|mdc)$/i.test(entry)) {
+                continue;
+            }
+            discovered.add(path.posix.join(relativeDir.replace(/\\/g, '/'), entry));
+        }
+    }
+    return [...discovered].sort((left, right) => left.localeCompare(right));
+}
+function inferBootstrapConfidence(input) {
+    if (input.workspaceKind === 'empty') {
+        return input.seedCount > 3 ? 'medium' : 'low';
+    }
+    if (input.readmePresent && (input.agentsPresent || input.nativeInstructionFiles.length > 0) && input.seedCount >= 6) {
+        return 'high';
+    }
+    if (input.readmePresent || input.nativeInstructionFiles.length > 0 || input.seedCount >= 4) {
+        return 'medium';
+    }
+    return 'low';
+}
+function inferBootstrapGaps(input) {
+    const gaps = [];
+    if (input.workspaceKind === 'empty') {
+        gaps.push('project intent is not documented yet');
+        gaps.push('agent workflow expectations should be captured explicitly');
+        return gaps;
+    }
+    if (!input.readmePresent) {
+        gaps.push('no README-level project overview detected');
+    }
+    if (input.nativeInstructionFiles.length === 0) {
+        gaps.push('no native agent instruction files detected');
+    }
+    if (input.seedCount < 4) {
+        gaps.push('derived context is sparse and may need an interview');
+    }
+    return gaps;
+}
 function scoreSeed(seed, target) {
     let score = seedKindWeight(seed.seed_kind) + confidenceWeight(seed.confidence);
     if (!target) {