brainclaw 1.8.0 → 1.9.1

package/dist/core/bootstrap.js

@@ -53,8 +53,8 @@ export function runBootstrapProfile(options = {}) {
     const existing = loadBootstrapProfile(cwd);
     const existingPlan = loadBootstrapImportPlan(cwd);
     const lastApplication = loadBootstrapApplication(cwd);
-    const existingFingerprint = currentRepoFingerprint(cwd);
-    if (!options.refresh && existing && existingPlan && isProfileReusable(existing, target, existingFingerprint)) {
+    const sourceFingerprint = currentSourceFingerprint(cwd, target);
+    if (!options.refresh && existing && existingPlan && isProfileReusable(existing, target, sourceFingerprint)) {
         const seeds = listBootstrapSeeds(cwd);
         const importPlan = interviewAnswers.length > 0
             ? buildBootstrapImportPlan({
@@ -81,7 +81,7 @@ export function runBootstrapProfile(options = {}) {
             reusedProfile: true,
         };
     }
-    const artifacts = buildBootstrapArtifacts({ cwd, target, repoFingerprint: existingFingerprint });
+    const artifacts = buildBootstrapArtifacts({ cwd, target, sourceFingerprint });
     persistBootstrapArtifacts(artifacts, cwd);
     const importPlan = interviewAnswers.length > 0
         ? buildBootstrapImportPlan({
@@ -124,7 +124,7 @@ export function hasReusableBootstrapProfile(target, cwd) {
     if (!profile) {
         return false;
     }
-    return isProfileReusable(profile, normalizeTarget(target), currentRepoFingerprint(cwd ?? process.cwd()));
+    return isProfileReusable(profile, normalizeTarget(target), currentSourceFingerprint(cwd ?? process.cwd(), target));
 }
 export function selectDerivedSignals(target, maxSignals, cwd) {
     const normalizedTarget = normalizeTarget(target);
@@ -342,7 +342,8 @@ function buildBootstrapArtifacts(input) {
         profile: BootstrapProfileDocumentSchema.parse({
             schema_version: DERIVED_SCHEMA_VERSION,
             derived_at: nowISO(),
-            repo_fingerprint: gitProbe.repoFingerprint ?? input.repoFingerprint,
+            repo_fingerprint: gitProbe.repoFingerprint,
+            source_fingerprint: input.sourceFingerprint ?? currentSourceFingerprint(input.cwd, input.target),
             summary,
             sources_scanned: [...new Set(sourcesScanned)],
             git_available: gitProbe.available,
@@ -627,28 +628,9 @@ function extractRepoAnalysisSeeds(result, target) {
 }
 function extractExecutionContextSeeds(snapshot, target) {
     const seeds = [];
-    if (snapshot.branch) {
-        seeds.push(createSeed({
-            text: `Current branch: ${snapshot.branch}`,
-            seedKind: 'environment',
-            sourceKind: 'machine',
-            sourceRef: 'git:branch',
-            confidence: 'high',
-            tags: ['bootstrap', 'execution', 'git'],
-            relatedPaths: target ? [target] : undefined,
-        }));
-    }
-    if (snapshot.git_status === 'dirty') {
-        seeds.push(createSeed({
-            text: 'Repository has uncommitted changes.',
-            seedKind: 'warning',
-            sourceKind: 'machine',
-            sourceRef: 'git:status',
-            confidence: 'high',
-            tags: ['bootstrap', 'execution', 'git'],
-            relatedPaths: target ? [target] : undefined,
-        }));
-    }
+    // Branch + dirty-status are execution-context-volatile (change on every
+    // checkout/edit). They stay on the live snapshot for display but must NOT
+    // be persisted as seeds — otherwise every dispatch invalidates the cache.
     for (const tool of snapshot.toolchains.slice(0, 3)) {
         seeds.push(createSeed({
             text: `Toolchain available: ${tool.name}${tool.version ? ` ${tool.version}` : ''}`,
@@ -735,25 +717,9 @@ function probeGit(cwd, target) {
             }));
         }
     }
-    // Step 13: Active branches
-    const branchResult = spawnSync('git', ['branch', '--no-merged', 'HEAD', '--format=%(refname:short)'], {
-        cwd,
-        encoding: 'utf-8',
-        timeout: 5000,
-    });
-    if (branchResult.status === 0) {
-        const branches = branchResult.stdout.split(/\r?\n/).map((b) => b.trim()).filter(Boolean).slice(0, 5);
-        for (const branch of branches) {
-            hotspotSeeds.push(createSeed({
-                text: `Active branch: ${branch}`,
-                seedKind: 'hotspot',
-                sourceKind: 'git',
-                sourceRef: `branch:${branch}`,
-                confidence: 'low',
-                tags: ['bootstrap', 'git', 'branch'],
-            }));
-        }
-    }
+    // Active branch names are execution-context-volatile (branches come and go
+    // every dispatch); we deliberately do not persist them as seeds — see the
+    // transient-seed policy in extractExecutionContextSeeds.
     // Step 13: Recent tags
     const tagResult = spawnSync('git', ['tag', '--sort=-creatordate', '-l'], {
         cwd,
@@ -827,18 +793,59 @@ function isProfileReusable(profile, target, currentFingerprint) {
     if ((profile.target ?? undefined) !== target) {
         return false;
     }
-    if (profile.repo_fingerprint && currentFingerprint) {
-        return profile.repo_fingerprint === currentFingerprint;
+    // Content fingerprint of the harvested sources, not git HEAD: a commit
+    // that touches no harvested doc/manifest must not trigger a full re-scan
+    // (which previously ran spawnSync git ×N + fs walks on every commit for
+    // low-density stores). Profiles persisted before source_fingerprint
+    // existed re-scan once and migrate.
+    if (profile.source_fingerprint !== currentFingerprint) {
+        return false;
+    }
+    // TTL backstop: git-history-derived seeds (hotspots) drift without any
+    // harvested file changing, so cap profile reuse in time.
+    const derivedAt = Date.parse(profile.derived_at);
+    if (!Number.isFinite(derivedAt) || Date.now() - derivedAt > BOOTSTRAP_PROFILE_TTL_MS) {
+        return false;
     }
     return true;
 }
-function currentRepoFingerprint(cwd) {
-    const result = spawnSync('git', ['rev-parse', 'HEAD'], {
-        cwd,
-        encoding: 'utf-8',
-        timeout: 5000,
-    });
-    return result.status === 0 ? result.stdout.trim() : undefined;
+const BOOTSTRAP_PROFILE_TTL_MS = 24 * 60 * 60 * 1000;
+const SOURCE_FINGERPRINT_EXTRA_FILES = [
+    'package.json',
+    MAKEFILE_NAME,
+];
+function currentSourceFingerprint(cwd, target) {
+    const scanRoot = resolveBootstrapScanRoot(cwd, normalizeTarget(target));
+    const candidates = new Set();
+    const readmePath = findFirstExisting(scanRoot, README_CANDIDATES);
+    if (readmePath) {
+        candidates.add(readmePath);
+    }
+    for (const relativePath of discoverNativeInstructionFiles(scanRoot)) {
+        candidates.add(path.join(scanRoot, relativePath));
+    }
+    for (const relativePath of [
+        ...SOURCE_FINGERPRINT_EXTRA_FILES,
+        ...CI_FILES,
+        ...CONTRIBUTING_FILES,
+        ...CHANGELOG_FILES,
+        ...DOCKER_FILES,
+        ...ENV_EXAMPLE_FILES,
+    ]) {
+        candidates.add(path.join(scanRoot, relativePath));
+    }
+    const entries = [];
+    for (const filepath of candidates) {
+        try {
+            const stat = fs.statSync(filepath);
+            if (stat.isFile()) {
+                entries.push(`${path.relative(scanRoot, filepath).replace(/\\/g, '/')}|${stat.size}|${Math.trunc(stat.mtimeMs)}`);
+            }
+        }
+        catch { /* missing file — not part of the fingerprint */ }
+    }
+    entries.sort();
+    return `src1:${crypto.createHash('sha1').update(entries.join('\n')).digest('hex')}`;
 }
 function createSeed(input) {
     return MemorySeedDocumentSchema.parse({
@@ -1167,6 +1174,9 @@ function renderBootstrapInterviewRationale(question) {
     return `Confirmed via bootstrap interview answer to ${question.id}: ${question.prompt}`;
 }
 function seedToBootstrapSuggestion(seed, allowSummaryFallback) {
+    if (seed.seed_kind === 'decision' || seed.seed_kind === 'constraint' || seed.seed_kind === 'trap') {
+        return seedToTypedSuggestion(seed);
+    }
     if (seed.seed_kind !== 'agent_rule' && seed.seed_kind !== 'command') {
         return undefined;
     }
@@ -1192,6 +1202,30 @@ function seedToBootstrapSuggestion(seed, allowSummaryFallback) {
         reversible: true,
     };
 }
+function seedToTypedSuggestion(seed) {
+    const target = seed.seed_kind === 'decision'
+        ? 'decision'
+        : seed.seed_kind === 'constraint' ? 'constraint' : 'trap';
+    const base = {
+        id: generateId('bootstrap_suggestions'),
+        target,
+        text: seed.text,
+        rationale: renderBootstrapSuggestionRationale(seed),
+        confidence: seed.confidence,
+        source_seed_ids: [seed.id],
+        source_refs: [seed.source_ref],
+        tags: normalizeBootstrapSuggestionTags(seed.tags),
+        related_paths: seed.related_paths,
+        reversible: true,
+    };
+    if (target === 'constraint') {
+        return { ...base, category: 'process' };
+    }
+    if (target === 'trap') {
+        return { ...base, severity: 'medium' };
+    }
+    return { ...base, outcome: 'pending' };
+}
 function inferBootstrapInstructionTarget(seed) {
     if (seed.source_kind === 'agents_md') {
         return { layer: 'global' };
@@ -1231,6 +1265,8 @@ function renderBootstrapSuggestionRationale(seed) {
             return `Derived from ${seed.source_ref}`;
         case 'manifest':
             return `Derived from ${seed.source_ref}`;
+        case 'adr':
+            return `Derived from architecture decision record ${seed.source_ref}`;
         default:
             return `Derived from ${seed.source_ref}`;
     }
@@ -1485,7 +1521,9 @@ export function uninstallBootstrapImport(cwd) {
             deletedCount++;
         }
         if (stateChanged) {
-            persistState(state, resolvedCwd, { writeProjectMarkdown: false });
+            // deleteMissing: uninstall removes managed artifacts — their files must be
+            // unlinked. Safe: loadState above runs under this same mutate() lock.
+            persistState(state, resolvedCwd, { writeProjectMarkdown: false, deleteMissing: true });
         }
         if (deactivatedCount > 0 || deletedCount > 0) {
             rebuildProjectMd(loadState(resolvedCwd), resolvedCwd);
@@ -1592,8 +1630,14 @@ function scoreSeed(seed, target) {
 }
 function seedKindWeight(kind) {
     switch (kind) {
+        case 'decision':
+            return 13;
         case 'agent_rule':
             return 12;
+        case 'constraint':
+            return 11;
+        case 'trap':
+            return 11;
         case 'warning':
             return 10;
         case 'tooling':
@@ -1804,17 +1848,24 @@ function extractAdditionalBrownfieldSeeds(cwd, target) {
         if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
             sources.push('adr');
             try {
-                const files = fs.readdirSync(fullPath).filter((f) => f.endsWith('.md'));
-                if (files.length > 0) {
-                    seeds.push(createSeed({
-                        text: `Architecture Decision Records: ${files.length} ADR(s) in ${dir}/`,
-                        seedKind: 'convention',
-                        sourceKind: 'adr',
-                        sourceRef: dir,
-                        confidence: 'high',
-                        tags: ['bootstrap', 'adr', 'architecture'],
-                        relatedPaths: target ? [target] : undefined,
-                    }));
+                const files = fs.readdirSync(fullPath)
+                    .filter((f) => f.endsWith('.md'))
+                    .map((name) => {
+                    const filePath = path.join(fullPath, name);
+                    let mtimeMs = 0;
+                    try {
+                        mtimeMs = fs.statSync(filePath).mtimeMs;
+                    }
+                    catch { /* ignore */ }
+                    return { name, filePath, mtimeMs };
+                })
+                    .sort((a, b) => b.mtimeMs - a.mtimeMs)
+                    .slice(0, ADR_READ_LIMIT);
+                for (const entry of files) {
+                    const adrSeed = extractAdrSeed(entry.filePath, dir, target);
+                    if (adrSeed) {
+                        seeds.push(adrSeed);
+                    }
                 }
             }
             catch { /* skip unreadable */ }
@@ -1823,4 +1874,119 @@ function extractAdditionalBrownfieldSeeds(cwd, target) {
     }
     return { seeds, sources: [...new Set(sources)] };
 }
+const ADR_READ_LIMIT = 20;
+const ADR_DECISION_EXCERPT_CAP = 600;
+function extractAdrSeed(filePath, dirRef, target) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+    if (!content.trim()) {
+        return undefined;
+    }
+    const parsed = parseAdrMarkdown(content);
+    const baseName = path.basename(filePath);
+    const sourceRef = path.posix.join(dirRef.replace(/\\/g, '/'), baseName);
+    const relatedPath = sourceRef;
+    const titleSegment = parsed.title ? parsed.title : baseName.replace(/\.md$/i, '');
+    const statusSegment = parsed.status ? ` [${parsed.status}]` : '';
+    const decisionSegment = parsed.decision
+        ? ` — ${parsed.decision}`
+        : '';
+    const fullText = `ADR ${titleSegment}${statusSegment}${decisionSegment}`.trim();
+    const text = fullText.length > ADR_DECISION_EXCERPT_CAP
+        ? `${fullText.slice(0, ADR_DECISION_EXCERPT_CAP - 1).trimEnd()}…`
+        : fullText;
+    return createSeed({
+        text,
+        seedKind: 'decision',
+        sourceKind: 'adr',
+        sourceRef,
+        confidence: 'high',
+        tags: ['bootstrap', 'adr', 'architecture'],
+        relatedPaths: target ? [relatedPath, target] : [relatedPath],
+        promotionHint: 'decision',
+    });
+}
+function parseAdrMarkdown(content) {
+    const lines = content.replace(/\r\n/g, '\n').split('\n');
+    const titleLine = lines.find((line) => /^#\s+/.test(line));
+    const title = titleLine ? titleLine.replace(/^#\s+/, '').trim() : undefined;
+    const sections = splitAdrSections(lines);
+    const statusSection = sections.find((s) => /^(status|statut)$/i.test(s.heading));
+    const status = statusSection ? firstNonEmptyLine(statusSection.body) : undefined;
+    const decisionSection = sections.find((s) => /^(decision|décision)$/i.test(s.heading));
+    let decision;
+    if (decisionSection) {
+        decision = firstParagraph(decisionSection.body);
+    }
+    if (!decision) {
+        const fallbackSection = sections.find((s) => !/^(status|statut|title|titre)$/i.test(s.heading));
+        if (fallbackSection) {
+            decision = firstParagraph(fallbackSection.body);
+        }
+    }
+    if (!decision) {
+        decision = firstNonTitleParagraph(lines);
+    }
+    if (decision && decision.length > ADR_DECISION_EXCERPT_CAP) {
+        decision = `${decision.slice(0, ADR_DECISION_EXCERPT_CAP - 1).trimEnd()}…`;
+    }
+    return { title, status, decision };
+}
+function splitAdrSections(lines) {
+    const sections = [];
+    let current;
+    for (const line of lines) {
+        const match = line.match(/^#{2,6}\s+(.+?)\s*$/);
+        if (match) {
+            if (current)
+                sections.push(current);
+            current = { heading: match[1].trim(), body: [] };
+        }
+        else if (current) {
+            current.body.push(line);
+        }
+    }
+    if (current)
+        sections.push(current);
+    return sections;
+}
+function firstNonEmptyLine(body) {
+    for (const line of body) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return undefined;
+}
+function firstParagraph(body) {
+    const paragraph = [];
+    for (const line of body) {
+        if (line.trim().length === 0) {
+            if (paragraph.length > 0)
+                break;
+            continue;
+        }
+        paragraph.push(line.trim());
+    }
+    return paragraph.length > 0 ? paragraph.join(' ') : undefined;
+}
+function firstNonTitleParagraph(lines) {
+    const paragraph = [];
+    for (const line of lines) {
+        if (/^#{1,6}\s+/.test(line))
+            continue;
+        if (line.trim().length === 0) {
+            if (paragraph.length > 0)
+                break;
+            continue;
+        }
+        paragraph.push(line.trim());
+    }
+    return paragraph.length > 0 ? paragraph.join(' ') : undefined;
+}
 //# sourceMappingURL=bootstrap.js.map

package/dist/core/brainclaw-version.js

@@ -221,6 +221,8 @@ export function publishLocalBrainclawRelease(cwd, options = {}) {
     const manifestPath = path.resolve(cwd, options.manifestPath ?? DEFAULT_LOCAL_RELEASE_MANIFEST_PATH);
     fs.mkdirSync(outputDir, { recursive: true });
     fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    runNpmScript(cwd, 'build:release');
+    runNpmScript(cwd, 'pack:check');
     const packResult = spawnSync(resolveNpmCommand(), resolveNpmPackArgs(outputDir), {
         cwd,
         encoding: 'utf-8',
@@ -488,6 +490,26 @@ function resolveNpmPackArgs(outputDir) {
     }
     return ['pack', '--json', '--pack-destination', outputDir];
 }
+function resolveNpmRunArgs(scriptName) {
+    if (process.platform === 'win32') {
+        return ['/d', '/s', '/c', 'npm', 'run', scriptName];
+    }
+    return ['run', scriptName];
+}
+function runNpmScript(cwd, scriptName) {
+    const result = spawnSync(resolveNpmCommand(), resolveNpmRunArgs(scriptName), {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 300000,
+    });
+    if (result.error) {
+        throw new Error(`Failed to run npm run ${scriptName}: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        const message = firstNonEmptyLine(result.stderr) ?? firstNonEmptyLine(result.stdout) ?? `npm run ${scriptName} failed`;
+        throw new Error(message);
+    }
+}
 function resolveNpmViewArgs(packageName) {
     if (process.platform === 'win32') {
         return ['/d', '/s', '/c', 'npm', 'view', packageName, 'dist-tags', '--json'];

package/dist/core/candidates.js

@@ -7,6 +7,7 @@ import { mutate } from './mutation-pipeline.js';
 import { nowISO, getNextShortLabel } from './ids.js';
 import { JsonStore } from './json-store.js';
 import { refreshLiveCompanions } from '../commands/export.js';
+import { emitRegistryPostImage, emitRegistryTombstone, registryFaultPoint } from './events/registry-post-image.js';
 /**
  * Return the effective source for a candidate.
  *
@@ -71,7 +72,13 @@ function candidateStore(dest = 'pending', cwd) {
 export function saveCandidate(candidate, cwd) {
     mutate({ cwd }, () => {
         ensureInboxDirs(cwd);
-        candidateStore('pending', cwd).save(CandidateSchema.parse(candidate));
+        const store = candidateStore('pending', cwd);
+        const parsed = CandidateSchema.parse(candidate);
+        // pln#568 (I2): journal the pending post-image BEFORE the projection write.
+        const created = !store.exists(parsed.id);
+        emitRegistryPostImage('candidate', parsed, { created, agent: parsed.author, agent_id: parsed.author_id, session_id: parsed.session_id, cwd });
+        registryFaultPoint('after_registry_journal');
+        store.save(parsed);
         // Auto-refresh live companions after candidate changes (non-fatal)
         try {
             refreshLiveCompanions(cwd);
@@ -108,6 +115,12 @@ function applySourceFilter(candidates, filter) {
 export function archiveCandidate(candidate, dest, cwd) {
     mutate({ cwd }, () => {
         ensureInboxDirs(cwd);
+        // pln#568 (I2): the candidate leaves the pending inbox — tombstone it in the
+        // journal BEFORE the projection delete, so the journal-materialized live set
+        // (and the observer's pending view) drops it. The accepted/rejected archive
+        // dirs are not journaled (the observer only tracks pending candidates).
+        emitRegistryTombstone('candidate', candidate.id, { agent: candidate.author, agent_id: candidate.author_id, session_id: candidate.session_id, cwd });
+        registryFaultPoint('after_registry_journal');
         candidateStore(dest, cwd).save(CandidateSchema.parse(candidate));
         candidateStore('pending', cwd).delete(candidate.id);
         // Auto-refresh live companions after candidate archive (non-fatal)
@@ -148,6 +161,13 @@ export function cleanupStaleCandidates(options = {}) {
     mutate({ cwd: options.cwd }, () => {
         const store = candidateStore('pending', options.cwd);
         for (const candidate of candidates) {
+            emitRegistryTombstone('candidate', candidate.id, {
+                agent: candidate.author,
+                agent_id: candidate.author_id,
+                session_id: candidate.session_id,
+                cwd: options.cwd,
+            });
+            registryFaultPoint('after_registry_journal');
             store.delete(candidate.id);
         }
         try {