@kentwynn/kgraph 0.2.19 → 0.2.20

package/dist/cli/commands/workflow.js

@@ -2,7 +2,7 @@ import { refreshCognitionReferenceStatuses, updateCognition, } from '../../cogni
 import { concludeTopic } from '../../cognition/conclusion.js';
 import { loadConfig } from '../../config/config.js';
 import { queryContext } from '../../context/context-query.js';
-import { readKnowledgeAtoms } from '../../knowledge/atom-store.js';
+import { refreshKnowledgeAtomStatuses } from '../../knowledge/atom-store.js';
 import { getWorkingTreeChanges } from '../../scanner/git-utils.js';
 import { scanRepository } from '../../scanner/repo-scanner.js';
 import { listInboxNotes } from '../../storage/cognition-store.js';
@@ -59,10 +59,22 @@ export async function runDefaultWorkflow(query, options = {}) {
                 console.error(`Warning: ${warning}`);
             }
         }
-        const atoms = await readKnowledgeAtoms(workspace);
+        const refreshedAtoms = await refreshKnowledgeAtomStatuses(workspace, {
+            fileMap: {
+                generatedAt: new Date().toISOString(),
+                files: scan.files,
+            },
+            symbolMap: {
+                generatedAt: new Date().toISOString(),
+                symbols: scan.symbols,
+            },
+        });
+        const atoms = refreshedAtoms.atoms;
         const pendingInbox = await listInboxNotes(workspace);
         const activeAtoms = atoms.filter((atom) => atom.status === 'active');
         const captureCheck = await buildCaptureCheck(workspace.rootPath, {
+            topic,
+            previousFiles: previousMaps.fileMap.files,
             files: scan.files,
             atoms,
         });
@@ -111,10 +123,21 @@ export async function runDefaultWorkflow(query, options = {}) {
 }
 async function buildCaptureCheck(rootPath, input) {
     const knownFiles = new Set(input.files.map((file) => file.path));
-    const changedFiles = (await getWorkingTreeChanges(rootPath)).filter((file) => knownFiles.has(file));
-    if (changedFiles.length === 0) {
-        return { required: false, changedFiles, coveredFiles: [] };
-    }
+    const previousByPath = new Map(input.previousFiles.map((file) => [file.path, file]));
+    const currentPaths = new Set(input.files.map((file) => file.path));
+    const mapChangedFiles = input.files
+        .filter((file) => {
+        const previous = previousByPath.get(file.path);
+        return !previous || previous.contentHash !== file.contentHash;
+    })
+        .map((file) => file.path);
+    const deletedFiles = input.previousFiles
+        .filter((file) => !currentPaths.has(file.path))
+        .map((file) => file.path);
+    const gitChangedFiles = (await getWorkingTreeChanges(rootPath)).filter((file) => knownFiles.has(file) || previousByPath.has(file));
+    const changedFiles = [
+        ...new Set([...mapChangedFiles, ...deletedFiles, ...gitChangedFiles]),
+    ];
     const recentCutoff = Date.now() - 24 * 60 * 60 * 1000;
     const recentActiveAtoms = input.atoms.filter((atom) => {
         if (atom.status !== 'active')
@@ -122,6 +145,7 @@ async function buildCaptureCheck(rootPath, input) {
         const createdAt = Date.parse(atom.provenance.createdAt);
         return Number.isFinite(createdAt) && createdAt >= recentCutoff;
     });
+    const invalidatedAtoms = matchingInvalidatedAtoms(input.atoms, input.topic).filter((atom) => !isInvalidatedAtomCovered(atom, recentActiveAtoms));
     const covered = new Set();
     for (const atom of recentActiveAtoms) {
         for (const ref of atom.evidenceRefs) {
@@ -136,16 +160,85 @@ async function buildCaptureCheck(rootPath, input) {
         }
     }
     return {
-        required: changedFiles.some((file) => !covered.has(file)),
+        required: changedFiles.some((file) => !covered.has(file)) ||
+            invalidatedAtoms.length > 0,
         changedFiles,
         coveredFiles: [...covered],
+        invalidatedAtoms,
     };
 }
+function isInvalidatedAtomCovered(invalidated, recentActiveAtoms) {
+    const invalidatedFiles = new Set(invalidated.scopeRefs.files);
+    const invalidatedSymbols = new Set(invalidated.scopeRefs.symbols);
+    for (const ref of invalidated.evidenceRefs) {
+        if (ref.type === 'file')
+            invalidatedFiles.add(ref.path);
+        if (ref.type === 'symbol')
+            invalidatedSymbols.add(ref.name);
+    }
+    return recentActiveAtoms.some((atom) => {
+        const atomFiles = new Set(atom.scopeRefs.files);
+        const atomSymbols = new Set(atom.scopeRefs.symbols);
+        for (const ref of atom.evidenceRefs) {
+            if (ref.type === 'file')
+                atomFiles.add(ref.path);
+            if (ref.type === 'symbol')
+                atomSymbols.add(ref.name);
+        }
+        const fileOverlap = [...invalidatedFiles].some((file) => atomFiles.has(file));
+        const symbolOverlap = [...invalidatedSymbols].some((symbol) => atomSymbols.has(symbol));
+        if (fileOverlap || symbolOverlap)
+            return true;
+        return tokenOverlap(invalidated.topic, atom.topic);
+    });
+}
+function tokenOverlap(a, b) {
+    const aTokens = new Set(a
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+    return b
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean)
+        .some((token) => aTokens.has(token));
+}
+function matchingInvalidatedAtoms(atoms, topic) {
+    const tokens = new Set((topic ?? '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+    return atoms.filter((atom) => {
+        if (atom.status !== 'needs-review' && atom.status !== 'stale')
+            return false;
+        if (tokens.size === 0)
+            return true;
+        const haystack = [
+            atom.topic,
+            atom.claim,
+            atom.summary,
+            ...atom.scopeRefs.files,
+            ...atom.scopeRefs.symbols,
+        ]
+            .filter(Boolean)
+            .join(' ')
+            .toLowerCase();
+        return [...tokens].some((token) => haystack.includes(token));
+    });
+}
 function renderFinalCaptureCheck(check, topic) {
     console.log('KGraph Final Check');
     if (check.changedFiles.length === 0) {
+        if (check.required) {
+            console.log('  status        capture-required');
+            console.log('  changed files 0');
+            console.log(`  invalid atoms ${check.invalidatedAtoms.length}`);
+            console.log('  conclusion    missing for needs-review or stale knowledge');
+            console.log(`  next          kgraph "${topic || '<topic>'}" --capture "<durable conclusion>" --capture-file <path>`);
+            return;
+        }
         console.log('  status        clean');
-        console.log('  reason        no mapped repo files changed');
+        console.log('  reason        no mapped repo files changed or invalidated matching atoms');
         return;
     }
     if (!check.required) {
@@ -156,6 +249,9 @@ function renderFinalCaptureCheck(check, topic) {
     }
     console.log('  status        capture-required');
     console.log(`  changed files ${check.changedFiles.length}`);
+    if (check.invalidatedAtoms.length > 0) {
+        console.log(`  invalid atoms ${check.invalidatedAtoms.length}`);
+    }
     console.log('  conclusion    missing for one or more changed files');
     console.log(`  next          kgraph "${topic || '<topic>'}" --capture "<durable conclusion>" --capture-file <path>`);
 }

package/dist/knowledge/atom-store.js

@@ -209,6 +209,8 @@ export async function validateKnowledgeStore(workspace, maps) {
         const symbolNames = new Set(maps.symbolMap.symbols.map((symbol) => symbol.name));
         const symbolIds = new Set(maps.symbolMap.symbols.map((symbol) => symbol.id));
         for (const atom of atoms) {
+            if (atom.status === 'archived')
+                continue;
             for (const ref of atom.evidenceRefs) {
                 if (ref.type === 'file') {
                     const file = fileByPath.get(ref.path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kentwynn/kgraph",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {