@cleocode/core 2026.4.31 → 2026.4.35

package/src/scaffold.ts

@@ -1348,6 +1348,48 @@ export function checkMemoryBridge(projectRoot: string): CheckResult {
   };
 }
 
+/**
+ * Verify .cleo/nexus-bridge.md exists.
+ * Warning level if missing (not failure) — it is auto-generated after `cleo nexus analyze`.
+ *
+ * @param projectRoot - Absolute path to the project root directory
+ * @returns Check result indicating presence of the nexus bridge file
+ *
+ * @remarks
+ * Read-only diagnostic. The nexus bridge is auto-generated from nexus.db
+ * content after `cleo nexus analyze` runs, so its absence is only a warning.
+ *
+ * @example
+ * ```typescript
+ * const check = checkNexusBridge('/my/project');
+ * if (check.status === 'warning') console.log('Run: cleo nexus analyze');
+ * ```
+ */
+export function checkNexusBridge(projectRoot: string): CheckResult {
+  const cleoDir = getCleoDirAbsolute(projectRoot);
+  const bridgePath = join(cleoDir, 'nexus-bridge.md');
+
+  if (!existsSync(bridgePath)) {
+    return {
+      id: 'nexus_bridge',
+      category: 'scaffold',
+      status: 'warning',
+      message: 'nexus-bridge.md not found',
+      details: { path: bridgePath, exists: false },
+      fix: 'cleo nexus analyze',
+    };
+  }
+
+  return {
+    id: 'nexus_bridge',
+    category: 'scaffold',
+    status: 'passed',
+    message: 'nexus-bridge.md exists',
+    details: { path: bridgePath, exists: true },
+    fix: null,
+  };
+}
+
 // ── Global (~/.cleo) scaffold functions ──────────────────────────────
 
 /**

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/brain-schema.ts

@@ -14,6 +14,57 @@ import { index, integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm
 
 // === ENUM CONSTANTS ===
 
+/**
+ * Memory retention tiers for the tiered cognitive memory model (T549).
+ *
+ * - `short`  — Session-scoped working context. Volatile; auto-evicted after 48h if not promoted.
+ * - `medium` — Project-scoped verified facts. Retained for weeks; decays if unverified.
+ * - `long`   — Architectural bedrock. Permanent; supersession-only eviction.
+ *
+ * NULL semantics for legacy rows: treat NULL as 'medium' at query time.
+ * (Legacy rows survived the T523 purge, so medium is a safe tier assumption.)
+ */
+export const BRAIN_MEMORY_TIERS = ['short', 'medium', 'long'] as const;
+
+/** Discriminated union of all memory retention tiers. */
+export type BrainMemoryTier = (typeof BRAIN_MEMORY_TIERS)[number];
+
+/**
+ * Cognitive type taxonomy for the tiered memory model (T549).
+ *
+ * Uses `BRAIN_COGNITIVE_TYPES` (not `BRAIN_MEMORY_TYPES`) to avoid collision
+ * with the link table enum `BRAIN_MEMORY_TYPES` (which stores entity type names).
+ *
+ * - `semantic`   — Declarative facts: "what is true about this project"
+ *                  → brain_decisions (always), brain_learnings (default)
+ * - `episodic`   — Event records: "what happened and when"
+ *                  → brain_observations (always), brain_learnings (transcript-derived)
+ * - `procedural` — Process knowledge: "how to do things"
+ *                  → brain_patterns (always)
+ */
+export const BRAIN_COGNITIVE_TYPES = ['semantic', 'episodic', 'procedural'] as const;
+
+/** Discriminated union of all cognitive memory types. */
+export type BrainCognitiveType = (typeof BRAIN_COGNITIVE_TYPES)[number];
+
+/**
+ * Source reliability levels for the tiered memory model (T549).
+ *
+ * Separate dimension from content `quality_score` — captures source trustworthiness.
+ * Each level drives a quality multiplier applied at scoring time.
+ *
+ * | Level         | Meaning                                 | Quality multiplier |
+ * |---------------|-----------------------------------------|--------------------|
+ * | `owner`       | Owner explicitly stated this fact       | 1.0                |
+ * | `task-outcome`| Verified by completed task with result  | 0.90               |
+ * | `agent`       | Agent-inferred during work (default)    | 0.70               |
+ * | `speculative` | Agent hypothesis, not yet corroborated  | 0.40               |
+ */
+export const BRAIN_SOURCE_CONFIDENCE = ['owner', 'task-outcome', 'agent', 'speculative'] as const;
+
+/** Discriminated union of all source confidence levels. */
+export type BrainSourceConfidence = (typeof BRAIN_SOURCE_CONFIDENCE)[number];
+
 /** Decision types from ADR-009. */
 export const BRAIN_DECISION_TYPES = [
   'architecture',
@@ -102,6 +153,46 @@ export const brainDecisions = sqliteTable(
     qualityScore: real('quality_score'),
     createdAt: text('created_at').notNull().default(sql`(datetime('now'))`),
     updatedAt: text('updated_at'),
+
+    // T549: Tiered + Typed Memory columns
+
+    /** Memory retention tier. NULL on legacy rows → treat as 'medium' at query time. */
+    memoryTier: text('memory_tier', { enum: BRAIN_MEMORY_TIERS }).default('short'),
+
+    /** Cognitive type. Decisions are always 'semantic' (declarative architectural facts). */
+    memoryType: text('memory_type', { enum: BRAIN_COGNITIVE_TYPES }).default('semantic'),
+
+    /**
+     * Ground-truth verification flag.
+     * false = agent-inferred, pending verification.
+     * true = confirmed via owner statement, task outcome, corroboration, or manual `cleo memory verify`.
+     */
+    verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+
+    /**
+     * Bitemporal: when this decision became valid (ISO 8601 text).
+     * Defaults to creation time. Can be backdated for historical facts.
+     */
+    validAt: text('valid_at').notNull().default(sql`(datetime('now'))`),
+
+    /**
+     * Bitemporal: when this decision stopped being valid.
+     * NULL = currently valid. Prefer `supersedes` graph edges for decision supersession
+     * (ADR-009); this column is a convenience gate for bulk eviction queries.
+     */
+    invalidAt: text('invalid_at'),
+
+    /**
+     * Source reliability level — separate from content quality_score (T549 §3.1.5).
+     * Drives quality multiplier at scoring time.
+     */
+    sourceConfidence: text('source_confidence', { enum: BRAIN_SOURCE_CONFIDENCE }).default('agent'),
+
+    /**
+     * Number of times this decision has been cited/retrieved (T549 CONFLICT-03).
+     * Used by the consolidator for citation-based medium→long promotion.
+     */
+    citationCount: integer('citation_count').notNull().default(0),
   },
   (table) => [
     index('idx_brain_decisions_type').on(table.type),
@@ -110,6 +201,12 @@ export const brainDecisions = sqliteTable(
     index('idx_brain_decisions_context_epic').on(table.contextEpicId),
     index('idx_brain_decisions_context_task').on(table.contextTaskId),
     index('idx_brain_decisions_quality').on(table.qualityScore),
+    // T549 indexes
+    index('idx_brain_decisions_tier').on(table.memoryTier),
+    index('idx_brain_decisions_mem_type').on(table.memoryType),
+    index('idx_brain_decisions_verified').on(table.verified),
+    index('idx_brain_decisions_valid_at').on(table.validAt),
+    index('idx_brain_decisions_source_conf').on(table.sourceConfidence),
   ],
 );
 
@@ -136,12 +233,57 @@ export const brainPatterns = sqliteTable(
      * Entries below 0.3 are excluded from search results (T531).
      */
     qualityScore: real('quality_score'),
+
+    // T549: Tiered + Typed Memory columns
+
+    /** Memory retention tier. NULL on legacy rows → treat as 'medium' at query time. */
+    memoryTier: text('memory_tier', { enum: BRAIN_MEMORY_TIERS }).default('short'),
+
+    /** Cognitive type. Patterns are always 'procedural' (process/workflow knowledge). */
+    memoryType: text('memory_type', { enum: BRAIN_COGNITIVE_TYPES }).default('procedural'),
+
+    /**
+     * Ground-truth verification flag.
+     * For patterns, this is complementary to frequency+successRate verification.
+     * false = agent-inferred. true = confirmed via owner statement or task outcome.
+     */
+    verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+
+    /**
+     * Bitemporal: when this pattern became valid (ISO 8601 text).
+     * Defaults to extraction time.
+     */
+    validAt: text('valid_at').notNull().default(sql`(datetime('now'))`),
+
+    /**
+     * Bitemporal: when this pattern stopped being valid.
+     * NULL = currently valid. Set by consolidator when frequency+successRate drops below threshold.
+     */
+    invalidAt: text('invalid_at'),
+
+    /**
+     * Source reliability level — separate from content quality_score (T549 §3.1.5).
+     * Drives quality multiplier at scoring time.
+     */
+    sourceConfidence: text('source_confidence', { enum: BRAIN_SOURCE_CONFIDENCE }).default('agent'),
+
+    /**
+     * Number of times this pattern has been cited/retrieved (T549 CONFLICT-03).
+     * Used by the consolidator for citation-based medium→long promotion.
+     */
+    citationCount: integer('citation_count').notNull().default(0),
   },
   (table) => [
     index('idx_brain_patterns_type').on(table.type),
     index('idx_brain_patterns_impact').on(table.impact),
     index('idx_brain_patterns_frequency').on(table.frequency),
     index('idx_brain_patterns_quality').on(table.qualityScore),
+    // T549 indexes
+    index('idx_brain_patterns_tier').on(table.memoryTier),
+    index('idx_brain_patterns_mem_type').on(table.memoryType),
+    index('idx_brain_patterns_verified').on(table.verified),
+    index('idx_brain_patterns_valid_at').on(table.validAt),
+    index('idx_brain_patterns_source_conf').on(table.sourceConfidence),
   ],
 );
 
@@ -165,11 +307,60 @@ export const brainLearnings = sqliteTable(
      * Entries below 0.3 are excluded from search results (T531).
      */
     qualityScore: real('quality_score'),
+
+    // T549: Tiered + Typed Memory columns
+
+    /** Memory retention tier. NULL on legacy rows → treat as 'medium' at query time. */
+    memoryTier: text('memory_tier', { enum: BRAIN_MEMORY_TIERS }).default('short'),
+
+    /**
+     * Cognitive type. Learnings are 'semantic' by default (declarative facts).
+     * Transcript-derived learnings with source containing 'transcript:ses_' are 'episodic'.
+     */
+    memoryType: text('memory_type', { enum: BRAIN_COGNITIVE_TYPES }).default('semantic'),
+
+    /**
+     * Ground-truth verification flag.
+     * false = agent-inferred, pending verification.
+     * true = confirmed via owner statement, task outcome, corroboration, or manual verify.
+     */
+    verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+
+    /**
+     * Bitemporal: when this learning became valid (ISO 8601 text).
+     * Defaults to creation time. Facts can change — use invalidAt to retire stale ones.
+     */
+    validAt: text('valid_at').notNull().default(sql`(datetime('now'))`),
+
+    /**
+     * Bitemporal: when this learning stopped being valid.
+     * NULL = currently valid. Set by consolidator on contradiction detection or TTL decay.
+     */
+    invalidAt: text('invalid_at'),
+
+    /**
+     * Source reliability level — separate from content quality_score (T549 §3.1.5).
+     * Drives quality multiplier at scoring time.
+     */
+    sourceConfidence: text('source_confidence', { enum: BRAIN_SOURCE_CONFIDENCE }).default('agent'),
+
+    /**
+     * Number of times this learning has been cited/retrieved (T549 CONFLICT-03).
+     * Used by the consolidator for citation-based medium→long promotion.
+     */
+    citationCount: integer('citation_count').notNull().default(0),
   },
   (table) => [
     index('idx_brain_learnings_confidence').on(table.confidence),
     index('idx_brain_learnings_actionable').on(table.actionable),
     index('idx_brain_learnings_quality').on(table.qualityScore),
+    // T549 indexes
+    index('idx_brain_learnings_tier').on(table.memoryTier),
+    index('idx_brain_learnings_mem_type').on(table.memoryType),
+    index('idx_brain_learnings_verified').on(table.verified),
+    index('idx_brain_learnings_valid_at').on(table.validAt),
+    index('idx_brain_learnings_invalid').on(table.invalidAt),
+    index('idx_brain_learnings_source_conf').on(table.sourceConfidence),
   ],
 );
 
@@ -205,6 +396,46 @@ export const brainObservations = sqliteTable(
     qualityScore: real('quality_score'),
     createdAt: text('created_at').notNull().default(sql`(datetime('now'))`),
     updatedAt: text('updated_at'),
+
+    // T549: Tiered + Typed Memory columns
+
+    /** Memory retention tier. NULL on legacy rows → treat as 'medium' at query time. */
+    memoryTier: text('memory_tier', { enum: BRAIN_MEMORY_TIERS }).default('short'),
+
+    /** Cognitive type. Observations are always 'episodic' (time-anchored event records). */
+    memoryType: text('memory_type', { enum: BRAIN_COGNITIVE_TYPES }).default('episodic'),
+
+    /**
+     * Ground-truth verification flag.
+     * false = agent-inferred, pending verification.
+     * true = confirmed via owner statement, task outcome, corroboration, or manual verify.
+     */
+    verified: integer('verified', { mode: 'boolean' }).notNull().default(false),
+
+    /**
+     * Bitemporal: when this observation became valid (ISO 8601 text).
+     * Defaults to creation time. Can be backdated for historical facts.
+     */
+    validAt: text('valid_at').notNull().default(sql`(datetime('now'))`),
+
+    /**
+     * Bitemporal: when this observation stopped being valid.
+     * NULL = currently valid. Set by consolidator on contradiction detection.
+     * Temporal query pattern: WHERE valid_at <= :t AND (invalid_at IS NULL OR invalid_at > :t)
+     */
+    invalidAt: text('invalid_at'),
+
+    /**
+     * Source reliability level — separate from content quality_score (T549 §3.1.5).
+     * Drives quality multiplier at scoring time.
+     */
+    sourceConfidence: text('source_confidence', { enum: BRAIN_SOURCE_CONFIDENCE }).default('agent'),
+
+    /**
+     * Number of times this observation has been cited/retrieved (T549 CONFLICT-03).
+     * Used by the consolidator for citation-based medium→long promotion.
+     */
+    citationCount: integer('citation_count').notNull().default(0),
   },
   (table) => [
     index('idx_brain_observations_type').on(table.type),
@@ -220,6 +451,13 @@ export const brainObservations = sqliteTable(
     index('idx_brain_observations_agent').on(table.agent),
     // T531: quality score filter index
     index('idx_brain_observations_quality').on(table.qualityScore),
+    // T549 indexes
+    index('idx_brain_observations_tier').on(table.memoryTier),
+    index('idx_brain_observations_mem_type').on(table.memoryType),
+    index('idx_brain_observations_verified').on(table.verified),
+    index('idx_brain_observations_valid_at').on(table.validAt),
+    index('idx_brain_observations_invalid').on(table.invalidAt),
+    index('idx_brain_observations_source_conf').on(table.sourceConfidence),
   ],
 );
 

package/src/store/brain-sqlite.ts

@@ -22,6 +22,7 @@ import { getCleoDirAbsolute } from '../paths.js';
 import * as brainSchema from './brain-schema.js';
 import {
   createSafetyBackup,
+  ensureColumns,
   migrateWithRetry,
   reconcileJournal,
   tableExists,
@@ -96,6 +97,60 @@ function runBrainMigrations(
   // Pass nativeDb + existenceTable so migrateWithRetry can auto-reconcile any
   // partial migration (Scenario 3) that slips through the proactive check above.
   migrateWithRetry(db, migrationsFolder, nativeDb, 'brain_decisions', 'brain');
+
+  // Safety net: ensure all columns from T528/T531/T549 exist even if the
+  // migration files were never committed to git or the journal was not updated.
+  // ensureColumns uses PRAGMA table_info + ALTER TABLE ADD COLUMN — idempotent.
+
+  // T528: graph schema expansion — quality scoring, content hashing, last-activity.
+  // Note: last_activity_at uses nullable text (no non-constant default) because
+  // ALTER TABLE ADD COLUMN with datetime('now') default fails on non-empty tables.
+  ensureColumns(
+    nativeDb,
+    'brain_page_nodes',
+    [
+      { name: 'quality_score', ddl: 'real DEFAULT 0.5' },
+      { name: 'content_hash', ddl: 'text' },
+      { name: 'last_activity_at', ddl: 'text' },
+      { name: 'updated_at', ddl: 'text' },
+    ],
+    'brain',
+  );
+
+  // T531: quality score on typed brain tables
+  for (const table of [
+    'brain_decisions',
+    'brain_patterns',
+    'brain_learnings',
+    'brain_observations',
+  ] as const) {
+    ensureColumns(nativeDb, table, [{ name: 'quality_score', ddl: 'real' }], 'brain');
+  }
+
+  // T549: tiered + typed memory architecture
+  for (const table of [
+    'brain_decisions',
+    'brain_patterns',
+    'brain_learnings',
+    'brain_observations',
+  ] as const) {
+    ensureColumns(
+      nativeDb,
+      table,
+      [
+        { name: 'memory_tier', ddl: "text DEFAULT 'short'" },
+        { name: 'memory_type', ddl: "text DEFAULT 'episodic'" },
+        { name: 'verified', ddl: 'integer NOT NULL DEFAULT 0' },
+        // valid_at uses nullable text (no datetime('now') default) because
+        // ALTER TABLE ADD COLUMN with non-constant defaults fails on non-empty tables.
+        { name: 'valid_at', ddl: 'text' },
+        { name: 'invalid_at', ddl: 'text' },
+        { name: 'source_confidence', ddl: "text DEFAULT 'agent'" },
+        { name: 'citation_count', ddl: 'integer NOT NULL DEFAULT 0' },
+      ],
+      'brain',
+    );
+  }
 }
 
 /**

package/src/store/migration-manager.ts

@@ -67,10 +67,41 @@ export function createSafetyBackup(dbPath: string): void {
   }
 }
 
+/**
+ * Insert a journal entry including `name` so Drizzle v1 beta (which checks by name,
+ * not hash) correctly identifies the migration as already applied.
+ *
+ * Emits INSERT OR IGNORE to avoid duplicate-row errors when called defensively.
+ */
+function insertJournalEntry(
+  nativeDb: DatabaseSync,
+  hash: string,
+  createdAt: number,
+  name: string,
+): void {
+  // Ensure the name and applied_at columns exist (Drizzle v1 beta schema).
+  // These are added by upgradeSyncIfNeeded, but reconcileJournal may run before
+  // the first migrate() call that triggers the upgrade.
+  const columns = nativeDb.prepare('PRAGMA table_info("__drizzle_migrations")').all() as Array<{
+    name: string;
+  }>;
+  const colNames = new Set(columns.map((c) => c.name));
+  if (!colNames.has('name')) {
+    nativeDb.exec('ALTER TABLE "__drizzle_migrations" ADD COLUMN "name" text');
+  }
+  if (!colNames.has('applied_at')) {
+    nativeDb.exec('ALTER TABLE "__drizzle_migrations" ADD COLUMN "applied_at" TEXT');
+  }
+
+  nativeDb.exec(
+    `INSERT OR IGNORE INTO "__drizzle_migrations" ("hash", "created_at", "name") VALUES ('${hash}', ${createdAt}, '${name}')`,
+  );
+}
+
 /**
  * Bootstrap and reconcile the Drizzle migration journal.
  *
- * Handles three scenarios:
+ * Handles four scenarios:
  * 1. Tables exist but no __drizzle_migrations — bootstrap baseline as applied
  * 2. Journal has orphaned hashes (from older CLEO version) — clear and re-mark all as applied
  * 3. Journal exists but is missing entries for migrations whose DDL has already been applied
@@ -78,6 +109,10 @@ export function createSafetyBackup(dbPath: string): void {
  *    migrations are cherry-picked from worktrees or the process crashes mid-migration).
  *    Auto-inserts the missing journal entry so Drizzle skips the migration instead of
  *    re-running ALTER TABLE and crashing on "duplicate column name".
+ * 4. Journal entries exist but have null `name` — Drizzle v1 beta identifies applied
+ *    migrations by name, so entries without a name are invisible to it, causing already-
+ *    applied migrations to be re-run and fail with "duplicate column name". Backfills
+ *    the name from the local migration file matched by hash.
  *
  * @param nativeDb - Native SQLite database handle
  * @param migrationsFolder - Path to the drizzle migrations folder
@@ -97,14 +132,14 @@ export function reconcileJournal(
     if (baseline) {
       nativeDb.exec(`
         CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
-          id SERIAL PRIMARY KEY,
+          id INTEGER PRIMARY KEY,
           hash text NOT NULL,
-          created_at numeric
+          created_at numeric,
+          name text,
+          applied_at TEXT
         )
       `);
-      nativeDb.exec(
-        `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${baseline.hash}', ${baseline.folderMillis})`,
-      );
+      insertJournalEntry(nativeDb, baseline.hash, baseline.folderMillis, baseline.name ?? '');
     }
   }
 
@@ -125,9 +160,7 @@ export function reconcileJournal(
       );
       nativeDb.exec('DELETE FROM "__drizzle_migrations"');
       for (const m of localMigrations) {
-        nativeDb.exec(
-          `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${m.hash}', ${m.folderMillis})`,
-        );
+        insertJournalEntry(nativeDb, m.hash, m.folderMillis, m.name ?? '');
       }
     }
   }
@@ -177,12 +210,50 @@ export function reconcileJournal(
           { migration: migration.name, columns: alterMatches },
           `Detected partially-applied migration ${migration.name} — columns exist but journal entry missing. Auto-reconciling.`,
         );
-        nativeDb.exec(
-          `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${migration.hash}', ${migration.folderMillis})`,
-        );
+        insertJournalEntry(nativeDb, migration.hash, migration.folderMillis, migration.name ?? '');
       }
     }
   }
+
+  // Scenario 4: Journal entries exist but have null `name`.
+  //
+  // Drizzle v1 beta changed getMigrationsToRun to filter by `name` (not hash).
+  // Journal entries inserted by older CLEO code (INSERT without "name") have
+  // name = null, which Drizzle filters out — making it treat those migrations as
+  // unapplied and re-run them. This causes "duplicate column name" failures for
+  // migrations whose DDL has already been applied.
+  //
+  // Fix: backfill `name` for any journal entries that have name = null but whose
+  // hash matches a known local migration file.
+  if (tableExists(nativeDb, '__drizzle_migrations') && tableExists(nativeDb, existenceTable)) {
+    // Check if the name column exists before querying it
+    const migCols = nativeDb.prepare('PRAGMA table_info("__drizzle_migrations")').all() as Array<{
+      name: string;
+    }>;
+    const hasMigNameCol = migCols.some((c) => c.name === 'name');
+    if (!hasMigNameCol) return; // name column absent — upgradeSyncIfNeeded will handle it
+
+    const localMigrations = readMigrationFiles({ migrationsFolder });
+    const hashToName = new Map(localMigrations.map((m) => [m.hash, m.name ?? '']));
+
+    const unnamedEntries = nativeDb
+      .prepare('SELECT id, hash FROM "__drizzle_migrations" WHERE name IS NULL')
+      .all() as Array<{ id: number; hash: string }>;
+
+    for (const entry of unnamedEntries) {
+      const migrationName = hashToName.get(entry.hash);
+      if (!migrationName) continue; // orphaned entry — leave for Scenario 2
+
+      const log = getLogger(logSubsystem);
+      log.warn(
+        { id: entry.id, hash: entry.hash, name: migrationName },
+        `Backfilling missing name on journal entry id=${entry.id} — Drizzle v1 beta requires name for applied-migration detection.`,
+      );
+      nativeDb.exec(
+        `UPDATE "__drizzle_migrations" SET "name" = '${migrationName}' WHERE id = ${entry.id}`,
+      );
+    }
+  }
 }
 
 /**

package/src/system/health.ts

@@ -21,6 +21,7 @@ import {
   checkGlobalTemplates,
   checkLogDir,
   checkMemoryBridge,
+  checkNexusBridge,
   checkProjectContext,
   checkProjectInfo,
   checkSqliteDb,
@@ -894,6 +895,14 @@ export async function coreDoctorReport(projectRoot: string): Promise<DoctorRepor
     ...(memBridgeCheckResult.fix ? { fix: memBridgeCheckResult.fix } : {}),
   });
 
+  const nexusBridgeCheckResult = checkNexusBridge(projectRoot);
+  checks.push({
+    check: 'nexus_bridge',
+    status: nexusBridgeCheckResult.status === 'passed' ? 'ok' : 'warning',
+    message: nexusBridgeCheckResult.message,
+    ...(nexusBridgeCheckResult.fix ? { fix: nexusBridgeCheckResult.fix } : {}),
+  });
+
   // 5f. Adapter health checks (T511 — wire adapter health into doctor)
   // `cleo adapter health` was previously isolated from the doctor report.
   // The doctor is the comprehensive diagnostic view so adapter health belongs here.
@@ -1384,6 +1393,14 @@ export async function startupHealthCheck(projectRoot?: string): Promise<StartupH
     message: memBridgeCheck.message,
   });
 
+  // Nexus bridge: info-level check (T552)
+  const nexusBridgeCheck = checkNexusBridge(root);
+  checks.push({
+    check: 'nexus_bridge',
+    status: nexusBridgeCheck.status === 'passed' ? 'pass' : 'warn',
+    message: nexusBridgeCheck.message,
+  });
+
   // NEXUS auto-registration (best-effort, never blocks startup)
   try {
     const { nexusReconcile } = await import('../nexus/registry.js');

package/src/tasks/graph-ops.ts

@@ -95,6 +95,7 @@ export function getNextTask(tasks: Task[]): Task | null {
   const ready = tasks
     .filter((t) => {
       if (t.status === 'done' || t.status === 'cancelled') return false;
+      if (t.cancelledAt) return false; // Exclude soft-cancelled tasks regardless of status
       if (t.status === 'active') return true; // Already active = highest priority
       if (!t.depends?.length) return true;
       return t.depends.every((d) => completedIds.has(d));

package/src/tasks/task-ops.ts

@@ -219,7 +219,7 @@ export async function coreTaskNext(
   const currentPhase = projectMeta?.currentPhase ?? null;
 
   const candidates = allTasks.filter(
-    (t) => t.status === 'pending' && depsReady(t.depends, taskMap),
+    (t) => t.status === 'pending' && !t.cancelledAt && depsReady(t.depends, taskMap),
   );
 
   if (candidates.length === 0) {

package/templates/CLEO-INJECTION.md

@@ -66,6 +66,21 @@ Check exit code (`0` = success) and `"success"` in JSON output after every comma
 - Token budget: avoid `cleo list` without `--parent`, avoid `cleo help --tier 2` before tier 0
 - Do not read full task details for tasks you won't work on
 
+## Memory Protocol (JIT)
+
+Pull context on demand — don't pre-load everything:
+
+| Need | Command |
+|------|---------|
+| Prior decisions | `cleo memory find "<topic>" --type decision` |
+| Known patterns | `cleo memory find "<domain>" --type pattern` |
+| Timeline context | `cleo memory timeline <id>` |
+| Full details | `cleo memory fetch <id>` |
+| Code context | `cleo nexus context <symbol>` |
+| Impact analysis | `cleo nexus impact <symbol>` |
+
+Budget: 3 JIT calls per task phase. More = task is underspecified.
+
 ## Escalation
 
 - Load **ct-cleo** skill for full protocol details