@cleocode/core 2026.3.61 → 2026.3.63

package/src/routing/capability-matrix.ts

@@ -469,6 +469,13 @@ const CAPABILITY_MATRIX: OperationCapability[] = [
     mode: 'native',
     preferredChannel: 'either',
   },
+  {
+    domain: 'admin',
+    operation: 'backup',
+    gateway: 'query',
+    mode: 'native',
+    preferredChannel: 'either',
+  },
   {
     domain: 'admin',
     operation: 'backup',

package/src/sequence/index.ts

@@ -168,7 +168,7 @@ export async function showSequence(cwd?: string): Promise<Record<string, unknown
     counter: seq.counter,
     lastId: seq.lastId,
     checksum: seq.checksum,
-    nextId: `T${seq.counter + 1}`,
+    nextId: `T${String(seq.counter + 1).padStart(3, '0')}`,
   };
 }
 

package/src/stats/index.ts

@@ -149,8 +149,10 @@ export async function getProjectStats(
       )
       .get();
     archivedCompleted = archivedDoneRow?.c ?? 0;
-    // totalCompleted = currently done (not yet archived) + archived-as-completed
-    totalCompleted = (statusMap['done'] ?? 0) + archivedCompleted;
+    // totalCompleted: use audit log as SSoT (same source as completedInPeriod) to ensure
+    // the two metrics are consistent. DB-based status counts under-count because they miss
+    // tasks that were completed then cancelled, deleted, or archived with a non-default reason.
+    totalCompleted = entries.filter(isComplete).length;
   } catch {
     // fallback to audit_log counts if DB unavailable
     totalCreated = entries.filter(isCreate).length;

package/src/store/brain-sqlite.ts

@@ -20,6 +20,7 @@ import { readMigrationFiles } from 'drizzle-orm/migrator';
 import type { NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
 import { drizzle } from 'drizzle-orm/node-sqlite';
 import { migrate } from 'drizzle-orm/node-sqlite/migrator';
+import { getLogger } from '../logger.js';
 import { getCleoDirAbsolute } from '../paths.js';
 import * as brainSchema from './brain-schema.js';
 import { isSqliteBusy, openNativeDatabase } from './sqlite.js';
@@ -119,6 +120,31 @@ function runBrainMigrations(
     }
   }
 
+  // Fix #65: Reconcile stale migration journal entries from older CLEO versions.
+  // Same pattern as tasks.db fix in sqlite.ts — see #63 for details.
+  if (tableExists(nativeDb, '__drizzle_migrations') && tableExists(nativeDb, 'brain_decisions')) {
+    const localMigrations = readMigrationFiles({ migrationsFolder });
+    const localHashes = new Set(localMigrations.map((m) => m.hash));
+    const dbEntries = nativeDb.prepare('SELECT hash FROM "__drizzle_migrations"').all() as Array<{
+      hash: string;
+    }>;
+    const hasOrphanedEntries = dbEntries.some((e) => !localHashes.has(e.hash));
+
+    if (hasOrphanedEntries) {
+      const log = getLogger('brain');
+      log.warn(
+        { orphaned: dbEntries.filter((e) => !localHashes.has(e.hash)).length },
+        'Detected stale migration journal entries from a previous CLEO version. Reconciling brain.db.',
+      );
+      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})`,
+        );
+      }
+    }
+  }
+
   // Run pending migrations via drizzle-orm/node-sqlite/migrator (synchronous).
   const MAX_RETRIES = 5;
   const BASE_DELAY_MS = 100;

package/src/system/backup.ts

@@ -3,7 +3,7 @@
  * @task T4783
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ExitCode } from '@cleocode/contracts';
 import { CleoError } from '../errors.js';
@@ -80,6 +80,57 @@ export function createBackup(
   return { backupId, path: backupDir, timestamp, type: btype, files: backedUp };
 }
 
+/** A single backup entry returned by listSystemBackups. */
+export interface BackupEntry {
+  backupId: string;
+  type: string;
+  timestamp: string;
+  note?: string;
+  files: string[];
+}
+
+/**
+ * List all available system backups (snapshot, safety, migration types).
+ * Reads `.meta.json` sidecar files written by createBackup.
+ * This is a pure read operation — it does not modify any files.
+ * @task T4783
+ */
+export function listSystemBackups(projectRoot: string): BackupEntry[] {
+  const cleoDir = join(projectRoot, '.cleo');
+  const backupTypes = ['snapshot', 'safety', 'migration'];
+  const entries: BackupEntry[] = [];
+
+  for (const btype of backupTypes) {
+    const backupDir = join(cleoDir, 'backups', btype);
+    if (!existsSync(backupDir)) continue;
+    try {
+      const files = readdirSync(backupDir).filter((f) => f.endsWith('.meta.json'));
+      for (const metaFile of files) {
+        try {
+          const raw = readFileSync(join(backupDir, metaFile), 'utf-8');
+          const meta = JSON.parse(raw) as Partial<BackupEntry>;
+          if (meta.backupId && meta.timestamp) {
+            entries.push({
+              backupId: meta.backupId,
+              type: meta.type ?? btype,
+              timestamp: meta.timestamp,
+              note: meta.note,
+              files: meta.files ?? [],
+            });
+          }
+        } catch {
+          // skip malformed meta files
+        }
+      }
+    } catch {
+      // skip unreadable backup directories
+    }
+  }
+
+  // Sort newest first
+  return entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+
 /** Restore from a backup. */
 export function restoreBackup(
   projectRoot: string,

package/src/tasks/__tests__/add.test.ts

@@ -286,7 +286,9 @@ describe('addTask (integration)', () => {
       accessor,
     );
     expect(result.dryRun).toBe(true);
-    expect(result.task.id).toBe('T001');
+    // Dry run does not allocate a real sequence ID — the task is a preview only
+    expect(result.task.id).toBe('T???');
+    expect(result.task.title).toBe('Dry run task');
   });
 
   it('validates parent hierarchy', async () => {

package/src/tasks/add.ts

@@ -645,6 +645,72 @@ export async function addTask(
     return { task: duplicate, duplicate: true };
   }
 
+  // Dry run: build a preview task without allocating a sequence ID or writing to the DB.
+  // Must be checked before allocateNextTaskId to avoid advancing the counter on no-op runs.
+  if (options.dryRun) {
+    const previewNow = new Date().toISOString();
+
+    // Resolve pipeline stage for the preview without any DB writes
+    let previewParentForStage: import('./pipeline-stage.js').ResolvedParent | null = null;
+    if (parentId) {
+      const previewParentTask = await dataAccessor.loadSingleTask(parentId);
+      previewParentForStage = previewParentTask
+        ? { pipelineStage: previewParentTask.pipelineStage, type: previewParentTask.type }
+        : null;
+    }
+    const previewPipelineStage = resolveDefaultPipelineStage({
+      explicitStage: options.pipelineStage,
+      taskType: taskType ?? null,
+      parentTask: previewParentForStage,
+    });
+    const previewPosition =
+      options.position !== undefined
+        ? options.position
+        : await dataAccessor.getNextPosition(parentId);
+
+    const previewTask: Task = {
+      id: 'T???',
+      title: options.title,
+      description: options.description,
+      status,
+      priority,
+      type: taskType,
+      parentId: parentId || null,
+      position: previewPosition,
+      positionVersion: 0,
+      size,
+      pipelineStage: previewPipelineStage,
+      createdAt: previewNow,
+      updatedAt: previewNow,
+    };
+    if (phase) previewTask.phase = phase;
+    if (options.labels?.length) previewTask.labels = options.labels.map((l) => l.trim());
+    if (options.files?.length) previewTask.files = options.files.map((f) => f.trim());
+    if (options.acceptance?.length)
+      previewTask.acceptance = options.acceptance.map((a) => a.trim());
+    if (options.depends?.length) previewTask.depends = options.depends.map((d) => d.trim());
+    if (options.notes) {
+      const previewNote = `${new Date()
+        .toISOString()
+        .replace('T', ' ')
+        .replace(/\.\d+Z$/, ' UTC')}: ${options.notes}`;
+      previewTask.notes = [previewNote];
+    }
+    if (status === 'blocked' && options.description) {
+      previewTask.blockedBy = options.description;
+    }
+    if (status === 'done') {
+      previewTask.completedAt = previewNow;
+    }
+    if (taskType !== 'epic') {
+      const verificationEnabledRaw = await getRawConfigValue('verification.enabled', cwd);
+      if (verificationEnabledRaw === true) {
+        previewTask.verification = buildDefaultVerification(previewNow);
+      }
+    }
+    return { task: previewTask, dryRun: true };
+  }
+
   const taskId = await allocateNextTaskId(cwd);
 
   const now = new Date().toISOString();
@@ -741,11 +807,6 @@ export async function addTask(
     }
   }
 
-  // Dry run
-  if (options.dryRun) {
-    return { task, dryRun: true };
-  }
-
   // Wrap all writes in a transaction for TOCTOU safety (T023)
   await dataAccessor.transaction(async (tx: TransactionAccessor) => {
     // Position shuffling via bulk SQL update (T025)