@cleocode/core 2026.3.37 → 2026.3.39

package/src/store/data-safety-central.ts

@@ -16,9 +16,9 @@
  * @epic T4732
  */
 
+import type { Session } from '@cleocode/contracts';
 import { getLogger } from '../logger.js';
 import { checkSequence, repairSequence } from '../sequence/index.js';
-import type { Session } from '@cleocode/contracts';
 import type { ArchiveFile, DataAccessor } from './data-accessor.js';
 import { gitCheckpoint } from './git-checkpoint.js';
 import { vacuumIntoBackup } from './sqlite-backup.js';

package/src/store/data-safety.ts

@@ -11,11 +11,10 @@
  * @epic T4732
  */
 
+import type { Session, Task } from '@cleocode/contracts';
 import { eq } from 'drizzle-orm';
 import { getLogger } from '../logger.js';
 import { checkSequence, repairSequence } from '../sequence/index.js';
-import type { Session } from '@cleocode/contracts';
-import type { Task } from '@cleocode/contracts';
 import { gitCheckpoint } from './git-checkpoint.js';
 import { getDb } from './sqlite.js';
 import { vacuumIntoBackup } from './sqlite-backup.js';

package/src/store/db-helpers.ts

@@ -7,12 +7,11 @@
  * @epic T4454
  */
 
+import type { Session, Task } from '@cleocode/contracts';
 import { eq, inArray } from 'drizzle-orm';
 import type { NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
-import type { Task } from '@cleocode/contracts';
 import type { NewTaskRow } from './tasks-schema.js';
 import * as schema from './tasks-schema.js';
-import type { Session } from './validation-schemas.js';
 
 /** Drizzle database instance type. */
 type DrizzleDb = NodeSQLiteDatabase<typeof schema>;

package/src/store/import-sort.ts

@@ -10,8 +10,8 @@
  * @epic T4545
  */
 
-import { CleoError } from '../errors.js';
 import { ExitCode } from '@cleocode/contracts';
+import { CleoError } from '../errors.js';
 
 /** Minimal task shape needed for topological sorting. */
 export interface SortableTask {

package/src/store/json.ts

@@ -6,8 +6,8 @@
  */
 
 import { createHash } from 'node:crypto';
-import { CleoError } from '../errors.js';
 import { ExitCode } from '@cleocode/contracts';
+import { CleoError } from '../errors.js';
 import { atomicWrite, atomicWriteJson, safeReadFile } from './atomic.js';
 import { createBackup } from './backup.js';
 import { withLock } from './lock.js';

package/src/store/lock.ts

@@ -5,9 +5,9 @@
  * @task T4457
  */
 
+import { ExitCode } from '@cleocode/contracts';
 import lockfile from 'proper-lockfile';
 import { CleoError } from '../errors.js';
-import { ExitCode } from '@cleocode/contracts';
 
 /** Default lock options. */
 const DEFAULT_LOCK_OPTIONS = {

package/src/store/migration-sqlite.ts

@@ -12,12 +12,11 @@
 
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import type { Session, Task } from '@cleocode/contracts';
 import type { NodeSQLiteDatabase } from 'drizzle-orm/node-sqlite';
 import { drizzle } from 'drizzle-orm/node-sqlite';
 import { migrate } from 'drizzle-orm/node-sqlite/migrator';
 import { getCleoDirAbsolute } from '../paths.js';
-import type { Session } from '@cleocode/contracts';
-import type { Task } from '@cleocode/contracts';
 import { dbExists, getDb, openNativeDatabase, resolveMigrationsFolder } from './sqlite.js';
 import type { SessionStatus } from './status-registry.js';
 import * as schema from './tasks-schema.js';

package/src/store/nexus-sqlite.ts

@@ -85,7 +85,9 @@ function runNexusMigrations(
     if (!existsSync(backupPath)) {
       try {
         copyFileSync(_nexusDbPath, backupPath);
-      } catch { /* non-fatal */ }
+      } catch {
+        /* non-fatal */
+      }
     }
   }
 
@@ -237,8 +239,8 @@ export function getNexusNativeDb(): DatabaseSync | null {
   return _nexusNativeDb;
 }
 
+export type { NodeSQLiteDatabase };
 /**
  * Re-export nexus schema for external use.
  */
 export { nexusSchema };
-export type { NodeSQLiteDatabase };

package/src/store/nexus-validation-schemas.ts

@@ -0,0 +1,61 @@
+/**
+ * Drizzle-derived Zod validation schemas for CLEO nexus.db tables.
+ *
+ * Uses `drizzle-orm/zod` to generate insert/select validation schemas
+ * directly from Drizzle table definitions in `./nexus-schema.ts`.
+ *
+ * Domain types (NexusProject, NexusRegistryFile, etc.) live in
+ * `../nexus/registry.ts` as plain interfaces — they have different
+ * field names from the DB rows, so they cannot be derived from
+ * createSelectSchema. The row-to-domain mapping is handled by
+ * `rowToProject()` in `../nexus/registry.ts`.
+ *
+ * @module nexus-validation-schemas
+ */
+
+import { createSchemaFactory } from 'drizzle-orm/zod';
+import { z } from 'zod/v4';
+
+// Use factory to bind our zod/v4 instance — ensures drizzle-orm/zod uses
+// the same z we use everywhere. The type assertion is needed because
+// drizzle-orm beta.18's CoerceOptions type doesn't match zod/v4's coerce
+// namespace shape (works correctly at runtime).
+const { createInsertSchema, createSelectSchema } = createSchemaFactory(
+  z as unknown as Parameters<typeof createSchemaFactory>[0],
+);
+
+import { nexusAuditLog, nexusSchemaMeta, projectRegistry } from './nexus-schema.js';
+
+// === PROJECT REGISTRY ===
+
+export const insertProjectRegistrySchema = createInsertSchema(projectRegistry, {
+  projectId: (s: z.ZodString) => s.min(1),
+  projectHash: (s: z.ZodString) => s.regex(/^[a-f0-9]{12}$/),
+  projectPath: (s: z.ZodString) => s.min(1),
+  name: (s: z.ZodString) => s.min(1).max(64),
+});
+export const selectProjectRegistrySchema = createSelectSchema(projectRegistry);
+
+// === NEXUS AUDIT LOG ===
+
+export const insertNexusAuditLogSchema = createInsertSchema(nexusAuditLog, {
+  id: (s: z.ZodString) => s.min(1),
+  action: (s: z.ZodString) => s.min(1).max(100),
+});
+export const selectNexusAuditLogSchema = createSelectSchema(nexusAuditLog);
+
+// === NEXUS SCHEMA META ===
+
+export const insertNexusSchemaMetaSchema = createInsertSchema(nexusSchemaMeta);
+export const selectNexusSchemaMetaSchema = createSelectSchema(nexusSchemaMeta);
+
+// === INFERRED TYPES ===
+
+export type InsertProjectRegistry = z.infer<typeof insertProjectRegistrySchema>;
+export type SelectProjectRegistry = z.infer<typeof selectProjectRegistrySchema>;
+
+export type InsertNexusAuditLog = z.infer<typeof insertNexusAuditLogSchema>;
+export type SelectNexusAuditLog = z.infer<typeof selectNexusAuditLogSchema>;
+
+export type InsertNexusSchemaMeta = z.infer<typeof insertNexusSchemaMetaSchema>;
+export type SelectNexusSchemaMeta = z.infer<typeof selectNexusSchemaMetaSchema>;

package/src/store/project-detect.ts

@@ -88,9 +88,6 @@ export interface ProjectContext {
   };
 }
 
-/** @deprecated Use ProjectContext instead. */
-export type ProjectInfo = ProjectContext;
-
 /**
  * Detect project type from directory contents.
  * Returns a schema-compliant ProjectContext object.

package/src/store/provider.ts

@@ -8,6 +8,7 @@
  * @task W1-T6
  */
 
+import type { Session, Task, TaskStatus, TaskType } from '@cleocode/contracts';
 import type {
   TaskCurrentResult,
   TaskStartResult,
@@ -22,8 +23,6 @@ import type { DeleteTaskOptions, DeleteTaskResult } from '../tasks/delete.js';
 import type { FindTasksOptions, FindTasksResult } from '../tasks/find.js';
 import type { ListTasksOptions, ListTasksResult } from '../tasks/list.js';
 import type { UpdateTaskOptions, UpdateTaskResult } from '../tasks/update.js';
-import type { Session } from '@cleocode/contracts';
-import type { Task, TaskStatus, TaskType } from '@cleocode/contracts';
 import type { DataAccessor } from './data-accessor.js';
 import { getAccessor } from './data-accessor.js';
 
@@ -31,22 +30,22 @@ import { getAccessor } from './data-accessor.js';
 export type {
   AddTaskOptions,
   AddTaskResult,
+  AnalysisResult,
+  ArchiveTasksOptions,
+  ArchiveTasksResult,
   CompleteTaskOptions,
   CompleteTaskResult,
-  UpdateTaskOptions,
-  UpdateTaskResult,
   DeleteTaskOptions,
   DeleteTaskResult,
   FindTasksOptions,
   FindTasksResult,
   ListTasksOptions,
   ListTasksResult,
-  ArchiveTasksOptions,
-  ArchiveTasksResult,
   TaskCurrentResult,
   TaskStartResult,
   TaskWorkHistoryEntry,
-  AnalysisResult,
+  UpdateTaskOptions,
+  UpdateTaskResult,
 };
 
 /**

package/src/store/safety-data-accessor.ts

@@ -14,9 +14,8 @@
  * @epic T4732
  */
 
+import type { Session, Task, TaskStatus } from '@cleocode/contracts';
 import { getLogger } from '../logger.js';
-import type { Session } from '@cleocode/contracts';
-import type { Task, TaskStatus } from '@cleocode/contracts';
 import type {
   ArchiveFile,
   DataAccessor,
@@ -214,7 +213,10 @@ export class SafetyDataAccessor implements DataAccessor {
     return this.inner.queryTasks(filters);
   }
 
-  async countTasks(filters?: { status?: TaskStatus | TaskStatus[]; parentId?: string }): Promise<number> {
+  async countTasks(filters?: {
+    status?: TaskStatus | TaskStatus[];
+    parentId?: string;
+  }): Promise<number> {
     return this.inner.countTasks(filters);
   }
 
@@ -271,7 +273,11 @@ export class SafetyDataAccessor implements DataAccessor {
     return this.inner.getNextPosition(parentId);
   }
 
-  async shiftPositions(parentId: string | null, fromPosition: number, delta: number): Promise<void> {
+  async shiftPositions(
+    parentId: string | null,
+    fromPosition: number,
+    delta: number,
+  ): Promise<void> {
     return this.inner.shiftPositions(parentId, fromPosition, delta);
   }
 

package/src/store/session-store.ts

@@ -7,8 +7,8 @@
  * @task W1-T4
  */
 
-import { and, desc, eq, isNull } from 'drizzle-orm';
 import type { Session } from '@cleocode/contracts';
+import { and, desc, eq, isNull } from 'drizzle-orm';
 import { rowToSession } from './converters.js';
 import { getDb } from './sqlite.js';
 import * as schema from './tasks-schema.js';

package/src/store/sqlite-data-accessor.ts

@@ -11,12 +11,8 @@
  * @epic T4454
  */
 
+import type { Session, Task, TaskStatus } from '@cleocode/contracts';
 import { and, eq, inArray, isNull, like, ne, notInArray, or, sql } from 'drizzle-orm';
-import type { Session } from '@cleocode/contracts';
-import type {
-  Task,
-  TaskStatus,
-} from '@cleocode/contracts';
 import { archivedTaskToRow, rowToSession, rowToTask, taskToRow } from './converters.js';
 import type {
   ArchiveFile,
@@ -449,7 +445,7 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
       const total = countResult?.count ?? 0;
 
       // Build ordered query
-      let orderClause;
+      let orderClause: ReturnType<typeof sql>;
       switch (filters.orderBy) {
         case 'createdAt':
           orderClause = sql`${schema.tasks.createdAt} ASC`;
@@ -491,9 +487,10 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
       return { tasks, total };
     },
 
-    async countTasks(
-      filters?: { status?: TaskStatus | TaskStatus[]; parentId?: string },
-    ): Promise<number> {
+    async countTasks(filters?: {
+      status?: TaskStatus | TaskStatus[];
+      parentId?: string;
+    }): Promise<number> {
       const db = await getDb(cwd);
       const conditions = [];
 
@@ -627,11 +624,7 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
 
       const db = await getDb(cwd);
       const ids = idRows.map((r) => r.id);
-      const rows = await db
-        .select()
-        .from(schema.tasks)
-        .where(inArray(schema.tasks.id, ids))
-        .all();
+      const rows = await db.select().from(schema.tasks).where(inArray(schema.tasks.id, ids)).all();
 
       const tasks = rows.map(rowToTask);
       if (tasks.length > 0) {
@@ -662,7 +655,7 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
 
       const tasks = rows.map(rowToTask);
       if (tasks.length > 0) {
-          const allIds = await getAllTaskIds();
+        const allIds = await getAllTaskIds();
         await loadDependenciesForTasks(db, tasks, allIds);
         await loadRelationsForTasks(db, tasks);
       }
@@ -710,7 +703,7 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
 
       const tasks = rows.map(rowToTask);
       if (tasks.length > 0) {
-          const allIds = await getAllTaskIds();
+        const allIds = await getAllTaskIds();
         await loadDependenciesForTasks(db, tasks, allIds);
         await loadRelationsForTasks(db, tasks);
       }
@@ -724,29 +717,42 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
       if (!nativeDb) {
         throw new Error('Native database not initialized');
       }
-      const row = parentId === null
-        ? nativeDb.prepare(
-            `SELECT COALESCE(MAX(position), 0) + 1 AS next_pos FROM tasks WHERE parent_id IS NULL AND status != 'archived'`,
-          ).get() as { next_pos: number } | undefined
-        : nativeDb.prepare(
-            `SELECT COALESCE(MAX(position), 0) + 1 AS next_pos FROM tasks WHERE parent_id = ? AND status != 'archived'`,
-          ).get(parentId) as { next_pos: number } | undefined;
+      const row =
+        parentId === null
+          ? (nativeDb
+              .prepare(
+                `SELECT COALESCE(MAX(position), 0) + 1 AS next_pos FROM tasks WHERE parent_id IS NULL AND status != 'archived'`,
+              )
+              .get() as { next_pos: number } | undefined)
+          : (nativeDb
+              .prepare(
+                `SELECT COALESCE(MAX(position), 0) + 1 AS next_pos FROM tasks WHERE parent_id = ? AND status != 'archived'`,
+              )
+              .get(parentId) as { next_pos: number } | undefined);
       return row?.next_pos ?? 1;
     },
 
-    async shiftPositions(parentId: string | null, fromPosition: number, delta: number): Promise<void> {
+    async shiftPositions(
+      parentId: string | null,
+      fromPosition: number,
+      delta: number,
+    ): Promise<void> {
       const nativeDb = getNativeTasksDb();
       if (!nativeDb) {
         throw new Error('Native database not initialized');
       }
       if (parentId === null) {
-        nativeDb.prepare(
-          `UPDATE tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id IS NULL AND position >= ? AND status != 'archived'`,
-        ).run(delta, new Date().toISOString(), fromPosition);
+        nativeDb
+          .prepare(
+            `UPDATE tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id IS NULL AND position >= ? AND status != 'archived'`,
+          )
+          .run(delta, new Date().toISOString(), fromPosition);
       } else {
-        nativeDb.prepare(
-          `UPDATE tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id = ? AND position >= ? AND status != 'archived'`,
-        ).run(delta, new Date().toISOString(), parentId, fromPosition);
+        nativeDb
+          .prepare(
+            `UPDATE tasks SET position = position + ?, position_version = position_version + 1, updated_at = ? WHERE parent_id = ? AND position >= ? AND status != 'archived'`,
+          )
+          .run(delta, new Date().toISOString(), parentId, fromPosition);
       }
     },
 
@@ -793,11 +799,7 @@ export async function createSqliteDataAccessor(cwd?: string): Promise<DataAccess
         }
       }
 
-      await db
-        .update(schema.tasks)
-        .set(updateRow)
-        .where(eq(schema.tasks.id, taskId))
-        .run();
+      await db.update(schema.tasks).set(updateRow).where(eq(schema.tasks.id, taskId)).run();
     },
 
     async transaction<T>(fn: (tx: TransactionAccessor) => Promise<T>): Promise<T> {

package/src/store/sqlite.ts

@@ -409,10 +409,7 @@ const MIGRATION_RETRY_MAX_DELAY_MS = 2000;
  * @task T4837 - ADR-012 drizzle-kit migration system
  * @task T5185 - Retry+backoff for SQLITE_BUSY during migrations
  */
-function runMigrations(
-  nativeDb: DatabaseSync,
-  db: NodeSQLiteDatabase<typeof schema>,
-): void {
+function runMigrations(nativeDb: DatabaseSync, db: NodeSQLiteDatabase<typeof schema>): void {
   const migrationsFolder = resolveMigrationsFolder();
 
   // If existing DB with pending migrations, create safety backup (cleo compat)
@@ -421,7 +418,9 @@ function runMigrations(
     if (!existsSync(backupPath)) {
       try {
         copyFileSync(_dbPath, backupPath);
-      } catch { /* non-fatal */ }
+      } catch {
+        /* non-fatal */
+      }
     }
   }
 
@@ -545,11 +544,11 @@ export function getNativeTasksDb(): DatabaseSync | null {
   return _nativeDb;
 }
 
+export type { NodeSQLiteDatabase };
 /**
  * Re-export schema for external use.
  */
 export { schema };
-export type { NodeSQLiteDatabase };
 
 /**
  * Close ALL database singletons (tasks.db, brain.db, nexus.db).

package/src/store/status-registry.ts

@@ -4,9 +4,21 @@
  * The canonical status definitions now live in @cleocode/contracts.
  * This file exists for backward compatibility within the store layer.
  */
+
+export type {
+  AdrStatus,
+  EntityType,
+  GateStatus,
+  ManifestStatus,
+  PipelineStatus,
+  SessionStatus,
+  StageStatus,
+  TaskStatus,
+} from '@cleocode/contracts';
 export {
   ADR_STATUSES,
   GATE_STATUSES,
+  isValidStatus,
   LIFECYCLE_PIPELINE_STATUSES,
   LIFECYCLE_STAGE_STATUSES,
   MANIFEST_STATUSES,
@@ -20,16 +32,4 @@ export {
   TERMINAL_PIPELINE_STATUSES,
   TERMINAL_STAGE_STATUSES,
   TERMINAL_TASK_STATUSES,
-  isValidStatus,
-} from '@cleocode/contracts';
-
-export type {
-  AdrStatus,
-  EntityType,
-  GateStatus,
-  ManifestStatus,
-  PipelineStatus,
-  SessionStatus,
-  StageStatus,
-  TaskStatus,
 } from '@cleocode/contracts';

package/src/store/task-store.ts

@@ -8,15 +8,15 @@
  * @task W1-T3
  */
 
-import { and, asc, count, eq, inArray, isNull, ne, sql } from 'drizzle-orm';
 import type { Task, TaskStatus, TaskType } from '@cleocode/contracts';
+import { and, asc, count, eq, inArray, isNull, ne, sql } from 'drizzle-orm';
+import { rowToTask, taskToRow } from './converters.js';
 import {
   type SafetyConfig,
   safeCreateTask,
   safeDeleteTask,
   safeUpdateTask,
 } from './data-safety.js';
-import { rowToTask, taskToRow } from './converters.js';
 import { getDb, getNativeDb } from './sqlite.js';
 import type { TaskRow } from './tasks-schema.js';
 import * as schema from './tasks-schema.js';

package/src/store/validation-schemas.ts

@@ -9,9 +9,17 @@
  * @task T3.4
  */
 
-import { createInsertSchema, createSelectSchema } from 'drizzle-orm/zod';
+import { createSchemaFactory } from 'drizzle-orm/zod';
 import { z } from 'zod/v4';
-import { SESSION_STATUSES } from './status-registry.js';
+
+// Use factory to bind our zod/v4 instance — ensures drizzle-orm/zod uses
+// the same z we use everywhere. The type assertion is needed because
+// drizzle-orm beta.18's CoerceOptions type doesn't match zod/v4's coerce
+// namespace shape (works correctly at runtime).
+const { createInsertSchema, createSelectSchema } = createSchemaFactory(
+  z as unknown as Parameters<typeof createSchemaFactory>[0],
+);
+
 import {
   architectureDecisions,
   auditLog,
@@ -57,80 +65,10 @@ export const selectTaskRelationSchema = createSelectSchema(taskRelations);
 export const insertSessionSchema = createInsertSchema(sessions);
 export const selectSessionSchema = createSelectSchema(sessions);
 
-// === SESSION DOMAIN TYPES (Drizzle-first) ===
-// Sub-schemas for JSON column shapes, domain transform, and type exports.
-// These are the SINGLE SOURCE OF TRUTH for all session types.
-
-/** Zod schema for the session scope JSON blob. */
-export const sessionScopeSchema = z.object({
-  type: z.string(),
-  epicId: z.string().optional(),
-  rootTaskId: z.string().optional(),
-  includeDescendants: z.boolean().optional(),
-  phaseFilter: z.union([z.string(), z.null()]).optional(),
-  labelFilter: z.union([z.array(z.string()), z.null()]).optional(),
-  maxDepth: z.union([z.number(), z.null()]).optional(),
-  explicitTaskIds: z.union([z.array(z.string()), z.null()]).optional(),
-  excludeTaskIds: z.union([z.array(z.string()), z.null()]).optional(),
-  computedTaskIds: z.array(z.string()).optional(),
-  computedAt: z.string().optional(),
-});
-
-/** Zod schema for session statistics. */
-export const sessionStatsSchema = z.object({
-  tasksCompleted: z.number(),
-  tasksCreated: z.number(),
-  tasksUpdated: z.number(),
-  focusChanges: z.number(),
-  totalActiveMinutes: z.number(),
-  suspendCount: z.number(),
-});
-
-/** Zod schema for active task work state within a session. */
-export const sessionTaskWorkSchema = z.object({
-  taskId: z.union([z.string(), z.null()]),
-  setAt: z.union([z.string(), z.null()]),
-});
-
-/** Inferred types from Zod sub-schemas. */
-export type SessionScope = z.infer<typeof sessionScopeSchema>;
-export type SessionStats = z.infer<typeof sessionStatsSchema>;
-export type SessionTaskWork = z.infer<typeof sessionTaskWorkSchema>;
-
-/**
- * Session domain schema — Zod object schema defining the canonical Session type.
- * Columns are derived from the Drizzle sessions table; JSON blobs use sub-schemas.
- * Non-required fields use .optional() so Session objects can be created ergonomically.
- *
- * This is the SINGLE SOURCE OF TRUTH for the Session type.
- */
-export const sessionSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  status: z.enum(SESSION_STATUSES),
-  scope: sessionScopeSchema,
-  taskWork: sessionTaskWorkSchema,
-  startedAt: z.string(),
-  endedAt: z.string().optional(),
-  agent: z.string().optional(),
-  notes: z.array(z.string()).optional(),
-  tasksCompleted: z.array(z.string()).optional(),
-  tasksCreated: z.array(z.string()).optional(),
-  handoffJson: z.string().nullable().optional(),
-  previousSessionId: z.string().nullable().optional(),
-  nextSessionId: z.string().nullable().optional(),
-  agentIdentifier: z.string().nullable().optional(),
-  handoffConsumedAt: z.string().nullable().optional(),
-  handoffConsumedBy: z.string().nullable().optional(),
-  debriefJson: z.string().nullable().optional(),
-  stats: sessionStatsSchema.optional(),
-  resumeCount: z.number().optional(),
-  gradeMode: z.boolean().optional(),
-  providerId: z.string().nullable().optional(),
-});
-
-/** Session domain type — derived from Zod schema aligned with Drizzle sessions table. */
-export type Session = z.infer<typeof sessionSchema>;
+// Session domain types (Session, SessionScope, SessionStats, SessionTaskWork)
+// are defined in @cleocode/contracts — the single source of truth.
+// The Drizzle-derived insertSessionSchema / selectSessionSchema above
+// handle DB row validation; no separate domain Zod schema is needed.
 
 // === TASK WORK HISTORY ===
 

package/src/system/__tests__/cleanup.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=cleanup.test.d.ts.map
+//# sourceMappingURL=cleanup.test.d.ts.map

package/src/system/__tests__/health.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=health.test.d.ts.map
+//# sourceMappingURL=health.test.d.ts.map