@kentwynn/kgraph 0.2.19 → 0.2.21

package/dist/cli/commands/workflow.js

@@ -2,8 +2,9 @@ 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 { shouldExclude } from '../../scanner/file-classifier.js';
 import { scanRepository } from '../../scanner/repo-scanner.js';
 import { listInboxNotes } from '../../storage/cognition-store.js';
 import { assertWorkspace, pathExists, resolveWorkspace, } from '../../storage/kgraph-paths.js';
@@ -59,10 +60,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.filter((file) => !shouldExclude(file.path, config)),
             files: scan.files,
             atoms,
         });
@@ -95,7 +108,7 @@ export async function runDefaultWorkflow(query, options = {}) {
         if (options.final) {
             console.log('');
             renderFinalCaptureCheck(captureCheck, topic);
-            if (captureCheck.required) {
+            if (captureCheck.required || captureCheck.unresolvedAtoms.length > 0) {
                 process.exitCode = 1;
             }
             return;
@@ -111,10 +124,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 +146,12 @@ 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 unresolvedAtoms = input.atoms.filter((atom) => atom.status === 'needs-review' || atom.status === 'stale');
+    const reviewItems = unresolvedAtoms.map((atom) => ({
+        atom,
+        replacement: findReplacementAtom(atom, recentActiveAtoms),
+    }));
     const covered = new Set();
     for (const atom of recentActiveAtoms) {
         for (const ref of atom.evidenceRefs) {
@@ -136,16 +166,136 @@ 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,
+        unresolvedAtoms,
+        reviewItems,
     };
 }
+function isInvalidatedAtomCovered(invalidated, recentActiveAtoms) {
+    return recentActiveAtoms.some((atom) => atomsOverlap(invalidated, atom));
+}
+function findReplacementAtom(invalidated, recentActiveAtoms) {
+    return recentActiveAtoms.find((atom) => atomsHaveReplacementSignal(invalidated, atom));
+}
+function atomsOverlap(a, b) {
+    const invalidatedFiles = new Set(a.scopeRefs.files);
+    const invalidatedSymbols = new Set(a.scopeRefs.symbols);
+    for (const ref of a.evidenceRefs) {
+        if (ref.type === 'file')
+            invalidatedFiles.add(ref.path);
+        if (ref.type === 'symbol')
+            invalidatedSymbols.add(ref.name);
+    }
+    const atomFiles = new Set(b.scopeRefs.files);
+    const atomSymbols = new Set(b.scopeRefs.symbols);
+    for (const ref of b.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(a.topic, b.topic);
+}
+function atomsHaveReplacementSignal(a, b) {
+    const aSymbols = new Set(a.scopeRefs.symbols);
+    for (const ref of a.evidenceRefs) {
+        if (ref.type === 'symbol')
+            aSymbols.add(ref.name);
+    }
+    const bSymbols = new Set(b.scopeRefs.symbols);
+    for (const ref of b.evidenceRefs) {
+        if (ref.type === 'symbol')
+            bSymbols.add(ref.name);
+    }
+    const symbolOverlap = [...aSymbols].some((symbol) => bSymbols.has(symbol));
+    return symbolOverlap || meaningfulTopicOverlap(a.topic, b.topic);
+}
+function meaningfulTopicOverlap(a, b) {
+    const weakTokens = new Set([
+        'add',
+        'after',
+        'behavior',
+        'change',
+        'changed',
+        'new',
+        'old',
+        'review',
+        'update',
+        'with',
+    ]);
+    const aTokens = new Set(a
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length > 2 && !weakTokens.has(token)));
+    return b
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((token) => token.length > 2 && !weakTokens.has(token))
+        .some((token) => aTokens.has(token));
+}
+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.required && check.unresolvedAtoms.length > 0) {
+        console.log('  status        memory-review-required');
+        console.log(`  unresolved    ${check.unresolvedAtoms.length}`);
+        console.log('  conclusion    stale or needs-review atoms remain');
+        renderMemoryReviewItems(check.reviewItems);
+        return;
+    }
     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}`);
+            renderMemoryReviewItems(check.reviewItems.filter((item) => check.invalidatedAtoms.some((atom) => atom.id === item.atom.id)));
+            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 +306,26 @@ 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}`);
+        renderMemoryReviewItems(check.reviewItems.filter((item) => check.invalidatedAtoms.some((atom) => atom.id === item.atom.id)));
+    }
     console.log('  conclusion    missing for one or more changed files');
     console.log(`  next          kgraph "${topic || '<topic>'}" --capture "<durable conclusion>" --capture-file <path>`);
 }
+function renderMemoryReviewItems(items) {
+    const visible = items.slice(0, 3);
+    for (const item of visible) {
+        console.log(`  review atom   ${item.atom.id}`);
+        console.log(`  review topic  ${item.atom.status}: ${item.atom.topic}`);
+        if (item.replacement) {
+            console.log(`  supersede     kgraph knowledge supersede ${item.atom.id} ${item.replacement.id}`);
+        }
+        else {
+            console.log(`  inspect       kgraph knowledge get ${item.atom.id}`);
+        }
+    }
+    if (items.length > visible.length) {
+        console.log(`  review more   ${items.length - visible.length} more atom(s)`);
+    }
+}

package/dist/config/config.js

@@ -23,6 +23,7 @@ export const DEFAULT_CONFIG = {
         '.agents',
         '.specify',
         'specs',
+        'tmp',
         '.cursor',
         '.claude',
         '.windsurf',

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.21",
   "description": "Persistent repo intelligence for AI coding assistants.",
   "type": "module",
   "bin": {