@cleocode/core 2026.4.30 → 2026.4.35

package/src/stats/index.ts

@@ -7,6 +7,7 @@
 import type { Task } from '@cleocode/contracts';
 import { ExitCode } from '@cleocode/contracts';
 import { CleoError } from '../errors.js';
+import { getProjectInfoSync } from '../project-info.js';
 import type { DataAccessor } from '../store/data-accessor.js';
 import { getAccessor } from '../store/data-accessor.js';
 
@@ -296,8 +297,14 @@ export async function getDashboard(
   }
 
   const meta = await acc.getMetaValue<import('@cleocode/contracts').ProjectMeta>('project_meta');
-  const project = meta?.name ?? 'Unknown Project';
-  const currentPhase = meta?.currentPhase ?? null;
+  // Fall back to the legacy 'project' key, then to the directory name from project-info.json
+  const legacyMeta = meta
+    ? null
+    : await acc.getMetaValue<{ name?: string; currentPhase?: string }>('project');
+  const resolvedName =
+    meta?.name ?? legacyMeta?.name ?? getProjectInfoSync(opts.cwd)?.projectName ?? null;
+  const project = resolvedName ?? 'Unknown Project';
+  const currentPhase = meta?.currentPhase ?? legacyMeta?.currentPhase ?? null;
 
   const focus = await acc.getMetaValue<import('@cleocode/contracts').TaskWorkState>('focus_state');
   const focusId = focus?.currentTask ?? null;
@@ -311,7 +318,8 @@ export async function getDashboard(
       (t) =>
         (t.priority === 'critical' || t.priority === 'high') &&
         t.status !== 'done' &&
-        t.status !== 'cancelled',
+        t.status !== 'cancelled' &&
+        !t.cancelledAt,
     )
     .sort((a, b) => {
       const pDiff =

package/src/store/__tests__/brain-accessor-pageindex.test.ts

@@ -5,6 +5,10 @@
  * addPageEdge, getPageEdges, getNeighbors, and removePageEdge using
  * in-memory brain.db instances.
  *
+ * Updated for T528: uses expanded BRAIN_NODE_TYPES and BRAIN_EDGE_TYPES.
+ * Old values mapped per T528 cross-validation report:
+ *   'doc' → 'concept', 'depends_on' → 'derived_from', 'relates_to' → 'informed_by'
+ *
  * @epic T5149
  * @task T5384
  */
@@ -49,6 +53,10 @@ describe('BrainDataAccessor PageIndex', () => {
     expect(node.label).toBe('BRAIN/NEXUS Cognitive Infrastructure');
     expect(node.metadataJson).toBe('{"priority":"critical"}');
     expect(node.createdAt).toBeTruthy();
+    // New fields with defaults
+    expect(node.qualityScore).toBe(0.5);
+    expect(node.contentHash).toBeNull();
+    expect(node.lastActivityAt).toBeTruthy();
   });
 
   it('getPageNode returns node by ID', async () => {
@@ -57,16 +65,17 @@ describe('BrainDataAccessor PageIndex', () => {
     closeBrainDb();
 
     const accessor = await getBrainAccessor();
+    // 'doc' was removed from BRAIN_NODE_TYPES in T528; use 'concept' instead
     await accessor.addPageNode({
-      id: 'doc:BRAIN-SPEC',
-      nodeType: 'doc',
+      id: 'concept:BRAIN-SPEC',
+      nodeType: 'concept',
       label: 'CLEO BRAIN Specification',
     });
 
-    const fetched = await accessor.getPageNode('doc:BRAIN-SPEC');
+    const fetched = await accessor.getPageNode('concept:BRAIN-SPEC');
     expect(fetched).not.toBeNull();
-    expect(fetched!.id).toBe('doc:BRAIN-SPEC');
-    expect(fetched!.nodeType).toBe('doc');
+    expect(fetched!.id).toBe('concept:BRAIN-SPEC');
+    expect(fetched!.nodeType).toBe('concept');
     expect(fetched!.label).toBe('CLEO BRAIN Specification');
   });
 
@@ -87,7 +96,8 @@ describe('BrainDataAccessor PageIndex', () => {
 
     const accessor = await getBrainAccessor();
     await accessor.addPageNode({ id: 'task:T1', nodeType: 'task', label: 'Task 1' });
-    await accessor.addPageNode({ id: 'doc:D1', nodeType: 'doc', label: 'Doc 1' });
+    // 'doc' removed in T528; use 'concept'
+    await accessor.addPageNode({ id: 'concept:D1', nodeType: 'concept', label: 'Concept 1' });
     await accessor.addPageNode({ id: 'task:T2', nodeType: 'task', label: 'Task 2' });
     await accessor.addPageNode({ id: 'file:F1', nodeType: 'file', label: 'File 1' });
 
@@ -95,14 +105,47 @@ describe('BrainDataAccessor PageIndex', () => {
     expect(tasks).toHaveLength(2);
     expect(tasks.every((n) => n.nodeType === 'task')).toBe(true);
 
-    const docs = await accessor.findPageNodes({ nodeType: 'doc' });
-    expect(docs).toHaveLength(1);
-    expect(docs[0]!.id).toBe('doc:D1');
+    const concepts = await accessor.findPageNodes({ nodeType: 'concept' });
+    expect(concepts).toHaveLength(1);
+    expect(concepts[0]!.id).toBe('concept:D1');
 
     const all = await accessor.findPageNodes();
     expect(all).toHaveLength(4);
   });
 
+  it('findPageNodes filters by minQualityScore', async () => {
+    const { getBrainAccessor } = await import('../brain-accessor.js');
+    const { closeBrainDb } = await import('../brain-sqlite.js');
+    closeBrainDb();
+
+    const accessor = await getBrainAccessor();
+    await accessor.addPageNode({
+      id: 'decision:D1',
+      nodeType: 'decision',
+      label: 'High quality',
+      qualityScore: 0.9,
+    });
+    await accessor.addPageNode({
+      id: 'decision:D2',
+      nodeType: 'decision',
+      label: 'Low quality',
+      qualityScore: 0.1,
+    });
+    await accessor.addPageNode({
+      id: 'decision:D3',
+      nodeType: 'decision',
+      label: 'Medium quality',
+      qualityScore: 0.5,
+    });
+
+    const highQuality = await accessor.findPageNodes({ minQualityScore: 0.8 });
+    expect(highQuality).toHaveLength(1);
+    expect(highQuality[0]!.id).toBe('decision:D1');
+
+    const mediumAndAbove = await accessor.findPageNodes({ minQualityScore: 0.5 });
+    expect(mediumAndAbove).toHaveLength(2);
+  });
+
   it('addPageEdge creates edge and returns it', async () => {
     const { getBrainAccessor } = await import('../brain-accessor.js');
     const { closeBrainDb } = await import('../brain-sqlite.js');
@@ -112,20 +155,41 @@ describe('BrainDataAccessor PageIndex', () => {
     await accessor.addPageNode({ id: 'task:T1', nodeType: 'task', label: 'Task 1' });
     await accessor.addPageNode({ id: 'task:T2', nodeType: 'task', label: 'Task 2' });
 
+    // 'depends_on' removed in T528; use 'derived_from'
     const edge = await accessor.addPageEdge({
       fromId: 'task:T1',
       toId: 'task:T2',
-      edgeType: 'depends_on',
+      edgeType: 'derived_from',
       weight: 0.8,
     });
 
     expect(edge.fromId).toBe('task:T1');
     expect(edge.toId).toBe('task:T2');
-    expect(edge.edgeType).toBe('depends_on');
+    expect(edge.edgeType).toBe('derived_from');
     expect(edge.weight).toBe(0.8);
     expect(edge.createdAt).toBeTruthy();
   });
 
+  it('addPageEdge supports provenance field', async () => {
+    const { getBrainAccessor } = await import('../brain-accessor.js');
+    const { closeBrainDb } = await import('../brain-sqlite.js');
+    closeBrainDb();
+
+    const accessor = await getBrainAccessor();
+    await accessor.addPageNode({ id: 'observation:O1', nodeType: 'observation', label: 'Obs 1' });
+    await accessor.addPageNode({ id: 'decision:D1', nodeType: 'decision', label: 'Decision 1' });
+
+    const edge = await accessor.addPageEdge({
+      fromId: 'observation:O1',
+      toId: 'decision:D1',
+      edgeType: 'supports',
+      provenance: 'auto:task-complete',
+    });
+
+    expect(edge.provenance).toBe('auto:task-complete');
+    expect(edge.weight).toBe(1.0);
+  });
+
   it('getPageEdges returns in/out/both edges', async () => {
     const { getBrainAccessor } = await import('../brain-accessor.js');
     const { closeBrainDb } = await import('../brain-sqlite.js');
@@ -134,9 +198,11 @@ describe('BrainDataAccessor PageIndex', () => {
     const accessor = await getBrainAccessor();
     await accessor.addPageNode({ id: 'A', nodeType: 'task', label: 'A' });
     await accessor.addPageNode({ id: 'B', nodeType: 'task', label: 'B' });
-    await accessor.addPageNode({ id: 'C', nodeType: 'doc', label: 'C' });
+    // 'concept' replaces 'doc'
+    await accessor.addPageNode({ id: 'C', nodeType: 'concept', label: 'C' });
 
-    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'depends_on' });
+    // 'depends_on' → 'derived_from'; 'documents' is still valid
+    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'derived_from' });
     await accessor.addPageEdge({ fromId: 'C', toId: 'A', edgeType: 'documents' });
 
     const outEdges = await accessor.getPageEdges('A', 'out');
@@ -159,15 +225,17 @@ describe('BrainDataAccessor PageIndex', () => {
     const accessor = await getBrainAccessor();
     await accessor.addPageNode({ id: 'A', nodeType: 'task', label: 'A' });
     await accessor.addPageNode({ id: 'B', nodeType: 'task', label: 'B' });
-    await accessor.addPageNode({ id: 'C', nodeType: 'doc', label: 'C' });
+    // 'concept' replaces 'doc'
+    await accessor.addPageNode({ id: 'C', nodeType: 'concept', label: 'C' });
 
-    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'depends_on' });
+    // 'depends_on' → 'derived_from'; 'documents' is still valid
+    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'derived_from' });
     await accessor.addPageEdge({ fromId: 'A', toId: 'C', edgeType: 'documents' });
 
     const allNeighbors = await accessor.getNeighbors('A');
     expect(allNeighbors).toHaveLength(2);
 
-    const depNeighbors = await accessor.getNeighbors('A', 'depends_on');
+    const depNeighbors = await accessor.getNeighbors('A', 'derived_from');
     expect(depNeighbors).toHaveLength(1);
     expect(depNeighbors[0]!.id).toBe('B');
   });
@@ -180,9 +248,11 @@ describe('BrainDataAccessor PageIndex', () => {
     const accessor = await getBrainAccessor();
     await accessor.addPageNode({ id: 'A', nodeType: 'task', label: 'A' });
     await accessor.addPageNode({ id: 'B', nodeType: 'task', label: 'B' });
-    await accessor.addPageNode({ id: 'C', nodeType: 'doc', label: 'C' });
+    // 'concept' replaces 'doc'
+    await accessor.addPageNode({ id: 'C', nodeType: 'concept', label: 'C' });
 
-    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'depends_on' });
+    // 'depends_on' → 'derived_from'; 'documents' is still valid
+    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'derived_from' });
     await accessor.addPageEdge({ fromId: 'C', toId: 'A', edgeType: 'documents' });
 
     await accessor.removePageNode('A');
@@ -209,16 +279,17 @@ describe('BrainDataAccessor PageIndex', () => {
     await accessor.addPageNode({ id: 'A', nodeType: 'task', label: 'A' });
     await accessor.addPageNode({ id: 'B', nodeType: 'task', label: 'B' });
 
-    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'depends_on' });
-    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'relates_to' });
+    // 'depends_on' → 'derived_from'; 'relates_to' → 'informed_by'
+    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'derived_from' });
+    await accessor.addPageEdge({ fromId: 'A', toId: 'B', edgeType: 'informed_by' });
 
     let edges = await accessor.getPageEdges('A', 'out');
     expect(edges).toHaveLength(2);
 
-    await accessor.removePageEdge('A', 'B', 'depends_on');
+    await accessor.removePageEdge('A', 'B', 'derived_from');
 
     edges = await accessor.getPageEdges('A', 'out');
     expect(edges).toHaveLength(1);
-    expect(edges[0]!.edgeType).toBe('relates_to');
+    expect(edges[0]!.edgeType).toBe('informed_by');
   });
 });

package/src/store/brain-accessor.ts

@@ -439,18 +439,25 @@ export class BrainDataAccessor {
   }
 
   async findPageNodes(
-    params: { nodeType?: (typeof brainSchema.BRAIN_NODE_TYPES)[number]; limit?: number } = {},
+    params: {
+      nodeType?: (typeof brainSchema.BRAIN_NODE_TYPES)[number];
+      minQualityScore?: number;
+      limit?: number;
+    } = {},
   ): Promise<BrainPageNodeRow[]> {
     const conditions: SQL[] = [];
 
     if (params.nodeType) {
       conditions.push(eq(brainSchema.brainPageNodes.nodeType, params.nodeType));
     }
+    if (params.minQualityScore !== undefined) {
+      conditions.push(gte(brainSchema.brainPageNodes.qualityScore, params.minQualityScore));
+    }
 
     let query = this.db
       .select()
       .from(brainSchema.brainPageNodes)
-      .orderBy(desc(brainSchema.brainPageNodes.createdAt));
+      .orderBy(desc(brainSchema.brainPageNodes.lastActivityAt));
 
     if (conditions.length > 0) {
       query = query.where(and(...conditions)) as typeof query;
@@ -463,6 +470,13 @@ export class BrainDataAccessor {
     return query;
   }
 
+  async updatePageNode(id: string, updates: Partial<NewBrainPageNodeRow>): Promise<void> {
+    await this.db
+      .update(brainSchema.brainPageNodes)
+      .set({ ...updates, updatedAt: new Date().toISOString().replace('T', ' ').slice(0, 19) })
+      .where(eq(brainSchema.brainPageNodes.id, id));
+  }
+
   async removePageNode(id: string): Promise<void> {
     // Remove associated edges first (both directions)
     await this.db
@@ -493,6 +507,38 @@ export class BrainDataAccessor {
     return result[0]!;
   }
 
+  async findPageEdges(
+    params: {
+      edgeType?: (typeof brainSchema.BRAIN_EDGE_TYPES)[number];
+      provenance?: string;
+      limit?: number;
+    } = {},
+  ): Promise<BrainPageEdgeRow[]> {
+    const conditions: SQL[] = [];
+
+    if (params.edgeType) {
+      conditions.push(eq(brainSchema.brainPageEdges.edgeType, params.edgeType));
+    }
+    if (params.provenance) {
+      conditions.push(eq(brainSchema.brainPageEdges.provenance, params.provenance));
+    }
+
+    let query = this.db
+      .select()
+      .from(brainSchema.brainPageEdges)
+      .orderBy(desc(brainSchema.brainPageEdges.createdAt));
+
+    if (conditions.length > 0) {
+      query = query.where(and(...conditions)) as typeof query;
+    }
+
+    if (params.limit) {
+      query = query.limit(params.limit) as typeof query;
+    }
+
+    return query;
+  }
+
   async getPageEdges(
     nodeId: string,
     direction: 'in' | 'out' | 'both' = 'both',