@cleocode/core 2026.4.39 → 2026.4.41

package/src/init.ts

@@ -832,65 +832,7 @@ export async function initProject(opts: InitOptions = {}): Promise<InitResult> {
   // This gives the CANT bridge a working team topology on first `cleoos` run.
   // Only deploys if .cleo/cant/ does not already contain .cant files (idempotent).
   try {
-    const cantDir = join(cleoDir, 'cant');
-    const cantAgentsDir = join(cantDir, 'agents');
-    const hasCantFiles =
-      existsSync(cantDir) &&
-      readdirSync(cantDir, { recursive: true }).some(
-        (f) => typeof f === 'string' && f.endsWith('.cant'),
-      );
-
-    if (!hasCantFiles) {
-      // Resolve the starter-bundle from @cleocode/cleo-os package
-      let starterBundleSrc: string | null = null;
-      try {
-        const { createRequire } = await import('node:module');
-        const req = createRequire(import.meta.url);
-        const cleoOsPkgMain = req.resolve('@cleocode/cleo-os/package.json');
-        const cleoOsPkgRoot = dirname(cleoOsPkgMain);
-        const candidate = join(cleoOsPkgRoot, 'starter-bundle');
-        if (existsSync(candidate)) {
-          starterBundleSrc = candidate;
-        }
-      } catch {
-        // Not resolvable via require.resolve — try workspace fallbacks
-      }
-
-      if (!starterBundleSrc) {
-        const packageRoot = getPackageRoot();
-        const fallbacks = [
-          join(packageRoot, '..', 'cleo-os', 'starter-bundle'),
-          join(packageRoot, '..', '..', 'packages', 'cleo-os', 'starter-bundle'),
-        ];
-        starterBundleSrc = fallbacks.find((p) => existsSync(p)) ?? null;
-      }
-
-      if (starterBundleSrc) {
-        await mkdir(cantDir, { recursive: true });
-        await mkdir(cantAgentsDir, { recursive: true });
-
-        // Copy team.cant
-        const teamSrc = join(starterBundleSrc, 'team.cant');
-        const teamDst = join(cantDir, 'team.cant');
-        if (existsSync(teamSrc) && !existsSync(teamDst)) {
-          await copyFile(teamSrc, teamDst);
-        }
-
-        // Copy agent .cant files
-        const agentsSrc = join(starterBundleSrc, 'agents');
-        if (existsSync(agentsSrc)) {
-          const agentFiles = readdirSync(agentsSrc).filter((f) => f.endsWith('.cant'));
-          for (const agentFile of agentFiles) {
-            const dst = join(cantAgentsDir, agentFile);
-            if (!existsSync(dst)) {
-              await copyFile(join(agentsSrc, agentFile), dst);
-            }
-          }
-        }
-
-        created.push('starter-bundle: team + agent .cant files deployed to .cleo/cant/');
-      }
-    }
+    await deployStarterBundle(cleoDir, created, warnings);
   } catch (err) {
     warnings.push(`Starter bundle deploy: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -1068,3 +1010,92 @@ export async function getVersion(projectRoot?: string): Promise<{ version: strin
 
   return { version: '0.0.0' };
 }
+
+// ---------------------------------------------------------------------------
+// Starter bundle deployment (T441) — shared between init and upgrade
+// ---------------------------------------------------------------------------
+
+/**
+ * Deploy the starter CANT bundle (team + agents) to a project's `.cleo/cant/`.
+ *
+ * Idempotent: skips deployment if `.cleo/cant/` already contains `.cant` files.
+ * Does not overwrite existing files. Resolves the starter bundle from
+ * `@cleocode/cleo-os/starter-bundle` or workspace fallback paths.
+ *
+ * Called by both `initProject()` and `runUpgrade()` to ensure every project
+ * gets a working team topology for the CANT bridge.
+ *
+ * @param cleoDir - Absolute path to the project's `.cleo/` directory.
+ * @param created - Array to push created-file descriptions into.
+ * @param warnings - Array to push warning messages into.
+ */
+export async function deployStarterBundle(
+  cleoDir: string,
+  created: string[],
+  warnings: string[],
+): Promise<void> {
+  const cantDir = join(cleoDir, 'cant');
+  const cantAgentsDir = join(cantDir, 'agents');
+  const hasCantFiles =
+    existsSync(cantDir) &&
+    readdirSync(cantDir, { recursive: true }).some(
+      (f) => typeof f === 'string' && f.endsWith('.cant'),
+    );
+
+  if (hasCantFiles) return; // Already deployed — idempotent
+
+  // Resolve the starter-bundle from @cleocode/cleo-os package
+  let starterBundleSrc: string | null = null;
+  try {
+    const { createRequire } = await import('node:module');
+    const req = createRequire(import.meta.url);
+    const cleoOsPkgMain = req.resolve('@cleocode/cleo-os/package.json');
+    const cleoOsPkgRoot = dirname(cleoOsPkgMain);
+    const candidate = join(cleoOsPkgRoot, 'starter-bundle');
+    if (existsSync(candidate)) {
+      starterBundleSrc = candidate;
+    }
+  } catch {
+    // Not resolvable via require.resolve — try workspace fallbacks
+  }
+
+  if (!starterBundleSrc) {
+    const packageRoot = getPackageRoot();
+    const fallbacks = [
+      join(packageRoot, '..', 'cleo-os', 'starter-bundle'),
+      join(packageRoot, '..', '..', 'packages', 'cleo-os', 'starter-bundle'),
+    ];
+    starterBundleSrc = fallbacks.find((p) => existsSync(p)) ?? null;
+  }
+
+  if (!starterBundleSrc) {
+    warnings.push(
+      'Starter bundle not found — .cleo/cant/ will remain empty. Run cleo init in a project with @cleocode/cleo-os installed.',
+    );
+    return;
+  }
+
+  await mkdir(cantDir, { recursive: true });
+  await mkdir(cantAgentsDir, { recursive: true });
+
+  // Copy team.cant
+  const teamSrc = join(starterBundleSrc, 'team.cant');
+  const teamDst = join(cantDir, 'team.cant');
+  if (existsSync(teamSrc) && !existsSync(teamDst)) {
+    await copyFile(teamSrc, teamDst);
+  }
+
+  // Copy agent .cant files
+  const agentsSrc = join(starterBundleSrc, 'agents');
+  if (existsSync(agentsSrc)) {
+    const agentFiles = readdirSync(agentsSrc).filter((f) => f.endsWith('.cant'));
+    for (const agentFile of agentFiles) {
+      const dst = join(cantAgentsDir, agentFile);
+      if (!existsSync(dst)) {
+        await copyFile(join(agentsSrc, agentFile), dst);
+      }
+    }
+  }
+
+  created.push('starter-bundle: team + agent .cant files deployed to .cleo/cant/');
+}

package/src/internal.ts

@@ -897,6 +897,13 @@ export type {
   BrainSearchHit,
   BrainTimelineNeighborRow,
 } from './memory/brain-row-types.js';
+export {
+  autoLinkMemories,
+  linkMemoryToCode,
+  listCodeLinks,
+  queryCodeForMemory,
+  queryMemoriesForCode,
+} from './memory/graph-memory-bridge.js';
 // Memory — LLM extraction gate (additional)
 export type {
   ExtractedMemory,

package/src/memory/__tests__/{graph-memory-bridge.test.ts → graph-memory-bridge-integration.test.ts}

@@ -12,7 +12,22 @@
 import { mkdir, mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Force-pass-through the real modules so that any leaked mocks from other
+// test files in the same vitest shard cannot pollute this integration test.
+// vitest resolves mocks at file-load time; vi.unmock is not sufficient when
+// another file's vi.mock('../../paths.js') already poisoned the module registry.
+vi.mock('../../paths.js', async () => await vi.importActual('../../paths.js'));
+vi.mock(
+  '../../store/brain-sqlite.js',
+  async () => await vi.importActual('../../store/brain-sqlite.js'),
+);
+vi.mock(
+  '../../store/nexus-sqlite.js',
+  async () => await vi.importActual('../../store/nexus-sqlite.js'),
+);
+vi.mock('../../config.js', async () => await vi.importActual('../../config.js'));
 
 let tempDir: string;
 
@@ -21,6 +36,9 @@ describe('graph-memory-bridge', () => {
     tempDir = await mkdtemp(join(tmpdir(), 'cleo-gmb-'));
     await mkdir(join(tempDir, '.cleo'), { recursive: true });
     process.env['CLEO_DIR'] = join(tempDir, '.cleo');
+    // nexus.db is global (ADR-036) — point CLEO_HOME to temp dir so
+    // getNexusDb() creates it here instead of ~/.cleo/ on CI.
+    process.env['CLEO_HOME'] = join(tempDir, '.cleo');
   });
 
   afterEach(async () => {
@@ -29,6 +47,7 @@ describe('graph-memory-bridge', () => {
     closeBrainDb();
     resetNexusDbState();
     delete process.env['CLEO_DIR'];
+    delete process.env['CLEO_HOME'];
     await rm(tempDir, { recursive: true, force: true });
   });
 

package/src/memory/__tests__/observer-reflector.test.ts

@@ -26,12 +26,14 @@ const {
   mockStoreLearning,
   mockStorePattern,
   mockLoadConfig,
+  mockResolveKey,
 } = vi.hoisted(() => ({
   mockGetBrainDb: vi.fn().mockResolvedValue({}),
   mockGetBrainNativeDb: vi.fn(),
   mockStoreLearning: vi.fn().mockResolvedValue({ id: 'L-test-001' }),
   mockStorePattern: vi.fn().mockResolvedValue({ id: 'P-test-001' }),
   mockLoadConfig: vi.fn(),
+  mockResolveKey: vi.fn().mockReturnValue(null),
 }));
 
 vi.mock('../../store/brain-sqlite.js', () => ({
@@ -56,6 +58,13 @@ vi.mock('../../config.js', () => ({
   loadConfig: mockLoadConfig,
 }));
 
+// Mock the key resolver so tests don't depend on filesystem state
+// (~/.claude/.credentials.json, ~/.local/share/cleo/anthropic-key).
+vi.mock('../anthropic-key-resolver.js', () => ({
+  resolveAnthropicApiKey: (...args: unknown[]) => mockResolveKey(...args),
+  clearAnthropicKeyCache: vi.fn(),
+}));
+
 // ============================================================================
 // Import module under test (after all mocks)
 // ============================================================================
@@ -69,11 +78,7 @@ import { runObserver, runReflector } from '../observer-reflector.js';
 const FAKE_API_KEY = 'sk-ant-test-key';
 
 function setApiKey(key: string | undefined): void {
-  if (key === undefined) {
-    delete process.env['ANTHROPIC_API_KEY'];
-  } else {
-    process.env['ANTHROPIC_API_KEY'] = key;
-  }
+  mockResolveKey.mockReturnValue(key ?? null);
 }
 
 type RawObs = {

package/src/memory/__tests__/sleep-consolidation.test.ts

@@ -171,7 +171,11 @@ function buildMockNativeDb(options: {
     return { run: mockRun, all: mockAll, get: vi.fn().mockReturnValue({ cnt: 0 }) };
   });
 
-  const stmtMock = { run: mockRun, all: vi.fn().mockReturnValue([]), get: vi.fn().mockReturnValue({ cnt: 0 }) };
+  const stmtMock = {
+    run: mockRun,
+    all: vi.fn().mockReturnValue([]),
+    get: vi.fn().mockReturnValue({ cnt: 0 }),
+  };
   return { prepare, _stmtMock: stmtMock };
 }
 

package/src/upgrade.ts

@@ -855,6 +855,21 @@ export async function runUpgrade(
       /* best-effort — signaldock.db will be created on first agent operation */
     }
 
+    // Initialize conduit.db for project-tier agent messaging (T310)
+    try {
+      const { ensureConduitDb } = await import('./store/conduit-sqlite.js');
+      const cdResult = ensureConduitDb(projectRootForMaint);
+      if (cdResult.action === 'created') {
+        actions.push({
+          action: 'ensure_conduit_db',
+          status: 'applied',
+          details: 'conduit.db created with full schema',
+        });
+      }
+    } catch {
+      /* best-effort — conduit.db will be created on first agent operation */
+    }
+
     // Regenerate memory-bridge.md
     try {
       const { writeMemoryBridge } = await import('./memory/memory-bridge.js');
@@ -900,7 +915,30 @@ export async function runUpgrade(
       /* best-effort */
     }
 
-    // (Step skipped — CLI dispatch only)
+    // Deploy starter CANT bundle (team + agents) to .cleo/cant/ if missing.
+    // Ensures existing projects get agent definitions on upgrade, not just init. (T555)
+    try {
+      const { deployStarterBundle } = await import('./init.js');
+      const cantCreated: string[] = [];
+      const cantWarnings: string[] = [];
+      await deployStarterBundle(cleoDir, cantCreated, cantWarnings);
+      if (cantCreated.length > 0) {
+        actions.push({
+          action: 'cant_starter_bundle',
+          status: 'applied',
+          details: cantCreated.join(', '),
+        });
+      }
+      for (const w of cantWarnings) {
+        actions.push({
+          action: 'cant_starter_bundle',
+          status: 'skipped',
+          details: w,
+        });
+      }
+    } catch {
+      /* best-effort */
+    }
 
     // Install core skills
     try {
@@ -992,6 +1030,51 @@ export async function runUpgrade(
     } catch {
       /* best-effort */
     }
+
+    // Adapter discovery, activation, and install (T5240)
+    // Ensures Claude Code settings.json hooks and other adapter configs stay current.
+    try {
+      const { AdapterManager } = await import('./adapters/index.js');
+      const mgr = AdapterManager.getInstance(projectRootForMaint);
+      const manifests = mgr.discover();
+      if (manifests.length > 0) {
+        const detected = mgr.detectActive();
+        for (const adapterId of detected) {
+          try {
+            const adapter = await mgr.activate(adapterId);
+            const installResult = await adapter.install.install({
+              projectDir: projectRootForMaint,
+            });
+            if (installResult.success) {
+              actions.push({
+                action: 'adapter_install',
+                status: 'applied',
+                details: `Adapter ${adapterId}: installed/updated`,
+              });
+            }
+          } catch {
+            /* best-effort — adapter may not support install */
+          }
+        }
+      }
+    } catch {
+      /* best-effort — adapters are optional */
+    }
+
+    // Ensure the global CleoOS Hub exists (idempotent)
+    try {
+      const { ensureCleoOsHub } = await import('./scaffold.js');
+      const hubResult = await ensureCleoOsHub();
+      if (hubResult.action === 'created') {
+        actions.push({
+          action: 'cleoos_hub',
+          status: 'applied',
+          details: hubResult.details ?? 'CleoOS hub scaffolded',
+        });
+      }
+    } catch {
+      /* best-effort */
+    }
   } else {
     // Dry-run reporting for new steps
     const { existsSync: fsExistsSync } = await import('node:fs');
@@ -1268,6 +1351,66 @@ export async function diagnoseUpgrade(options: { cwd?: string } = {}): Promise<D
             fix: 'Run: cleo upgrade',
           });
         }
+
+        // T528/T531/T549 column validation — ensure brain schema expansions applied
+        const brainColumnChecks: Array<{ table: string; columns: string[]; task: string }> = [
+          {
+            table: 'brain_page_nodes',
+            columns: ['quality_score', 'content_hash', 'last_activity_at', 'updated_at'],
+            task: 'T528',
+          },
+          {
+            table: 'brain_decisions',
+            columns: [
+              'quality_score',
+              'memory_tier',
+              'memory_type',
+              'verified',
+              'valid_at',
+              'invalid_at',
+              'source_confidence',
+              'citation_count',
+            ],
+            task: 'T531/T549',
+          },
+          {
+            table: 'brain_observations',
+            columns: ['quality_score', 'memory_tier', 'memory_type', 'verified'],
+            task: 'T531/T549',
+          },
+        ];
+
+        const allBrainColsMissing: string[] = [];
+        for (const { table, columns, task } of brainColumnChecks) {
+          const hasTable = nativeDb
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+            .get(table) as { name?: string } | undefined;
+          if (!hasTable?.name) continue;
+
+          const cols = nativeDb.prepare(`PRAGMA table_info(${table})`).all() as Array<{
+            name: string;
+          }>;
+          const colNames = new Set(cols.map((c: { name: string }) => c.name));
+          const missing = columns.filter((c) => !colNames.has(c));
+          if (missing.length > 0) {
+            allBrainColsMissing.push(`${table}: ${missing.join(', ')} (${task})`);
+          }
+        }
+
+        if (allBrainColsMissing.length > 0) {
+          findings.push({
+            check: 'brain.db.schema_columns',
+            status: 'error',
+            details: `Missing brain schema columns: ${allBrainColsMissing.join('; ')}`,
+            fix: 'Run: cleo upgrade (will add missing columns automatically)',
+          });
+        } else {
+          findings.push({
+            check: 'brain.db.schema_columns',
+            status: 'ok',
+            details: 'All T528/T531/T549 brain schema columns present',
+          });
+        }
       } else {
         findings.push({
           check: 'brain.db.connection',
@@ -1287,6 +1430,85 @@ export async function diagnoseUpgrade(options: { cwd?: string } = {}): Promise<D
       check: 'brain.db',
       status: 'warning',
       details: 'brain.db not found (will be created on first use)',
+      fix: 'Run: cleo upgrade',
+    });
+  }
+
+  // ── signaldock.db validation ──
+  const signaldockDbPath = join(cleoDir, 'signaldock.db');
+  if (existsSync(signaldockDbPath)) {
+    findings.push({
+      check: 'signaldock.db',
+      status: 'ok',
+      details: 'signaldock.db exists',
+    });
+  } else {
+    findings.push({
+      check: 'signaldock.db',
+      status: 'warning',
+      details: 'signaldock.db not found',
+      fix: 'Run: cleo upgrade',
+    });
+  }
+
+  // ── conduit.db validation ──
+  const conduitDbPath = join(cleoDir, 'conduit.db');
+  if (existsSync(conduitDbPath)) {
+    findings.push({
+      check: 'conduit.db',
+      status: 'ok',
+      details: 'conduit.db exists',
+    });
+  } else {
+    findings.push({
+      check: 'conduit.db',
+      status: 'warning',
+      details: 'conduit.db not found',
+      fix: 'Run: cleo upgrade',
+    });
+  }
+
+  // ── memory-bridge.md validation ──
+  const memoryBridgePath = join(cleoDir, 'memory-bridge.md');
+  if (existsSync(memoryBridgePath)) {
+    try {
+      const content = readFileSync(memoryBridgePath, 'utf-8');
+      const hasAutoGenMarker = content.includes('Auto-generated');
+      const hasGarbage = content.includes('undefined') && content.length < 100;
+      if (hasGarbage) {
+        findings.push({
+          check: 'memory-bridge.md',
+          status: 'error',
+          details: 'memory-bridge.md contains garbage content',
+          fix: 'Run: cleo upgrade (will regenerate)',
+        });
+      } else if (hasAutoGenMarker) {
+        findings.push({
+          check: 'memory-bridge.md',
+          status: 'ok',
+          details: 'memory-bridge.md exists and has valid content',
+        });
+      } else {
+        findings.push({
+          check: 'memory-bridge.md',
+          status: 'warning',
+          details: 'memory-bridge.md exists but may be stale (no auto-generated marker)',
+          fix: 'Run: cleo upgrade (will regenerate)',
+        });
+      }
+    } catch {
+      findings.push({
+        check: 'memory-bridge.md',
+        status: 'warning',
+        details: 'memory-bridge.md exists but could not be read',
+      });
+    }
+  } else {
+    findings.push({
+      check: 'memory-bridge.md',
+      status: 'warning',
+      details: 'memory-bridge.md not found',
+      fix: 'Run: cleo upgrade (will regenerate)',
     });
   }