@cleocode/core 2026.3.43 → 2026.3.44

package/src/store/validation-schemas.ts

@@ -5,6 +5,9 @@
  * directly from Drizzle table definitions in `./schema.ts`. This ensures
  * validation rules stay in sync with the database schema automatically.
  *
+ * Also exports canonical Zod enum schemas for all domain enums so that
+ * consumers (e.g. CleoOS, plugins) can import them instead of duplicating.
+ *
  * @module validation-schemas
  * @task T3.4
  */
@@ -20,17 +23,67 @@ const { createInsertSchema, createSelectSchema } = createSchemaFactory(
   z as unknown as Parameters<typeof createSchemaFactory>[0],
 );
 
+// Brain enum constants
+import {
+  BRAIN_CONFIDENCE_LEVELS,
+  BRAIN_DECISION_TYPES,
+  BRAIN_EDGE_TYPES,
+  BRAIN_IMPACT_LEVELS,
+  BRAIN_LINK_TYPES,
+  BRAIN_MEMORY_TYPES,
+  BRAIN_NODE_TYPES,
+  BRAIN_OBSERVATION_SOURCE_TYPES,
+  BRAIN_OBSERVATION_TYPES,
+  BRAIN_OUTCOME_TYPES,
+  BRAIN_PATTERN_TYPES,
+  BRAIN_STICKY_COLORS,
+  BRAIN_STICKY_PRIORITIES,
+  BRAIN_STICKY_STATUSES,
+} from './brain-schema.js';
+
+// Status constants from the canonical registry
+import {
+  ADR_STATUSES,
+  GATE_STATUSES,
+  LIFECYCLE_PIPELINE_STATUSES,
+  LIFECYCLE_STAGE_STATUSES,
+  MANIFEST_STATUSES,
+  SESSION_STATUSES,
+  TASK_STATUSES,
+} from './status-registry.js';
 import {
+  // Agent enum constants
+  AGENT_INSTANCE_STATUSES,
+  AGENT_TYPES,
+  agentErrorLog,
+  agentInstances,
   architectureDecisions,
   auditLog,
+  // Enum constants (non-status) from tasks-schema
+  EXTERNAL_LINK_TYPES,
+  externalTaskLinks,
+  LIFECYCLE_EVIDENCE_TYPES,
+  LIFECYCLE_GATE_RESULTS,
+  LIFECYCLE_STAGE_NAMES,
+  LIFECYCLE_TRANSITION_TYPES,
   lifecycleEvidence,
   lifecycleGateResults,
   lifecyclePipelines,
   lifecycleStages,
   lifecycleTransitions,
   manifestEntries,
+  pipelineManifest,
+  releaseManifests,
+  SYNC_DIRECTIONS,
   schemaMeta,
   sessions,
+  TASK_PRIORITIES,
+  TASK_RELATION_TYPES,
+  TASK_SIZES,
+  TASK_TYPES,
+  TOKEN_USAGE_CONFIDENCE,
+  TOKEN_USAGE_METHODS,
+  TOKEN_USAGE_TRANSPORTS,
   taskDependencies,
   taskRelations,
   tasks,
@@ -38,6 +91,104 @@ import {
   tokenUsage,
 } from './tasks-schema.js';
 
+// =========================================================================
+// CANONICAL ZOD ENUM SCHEMAS
+// =========================================================================
+// These are the single source of truth for enum validation that consumers
+// (e.g. CleoOS tRPC routers) should import instead of duplicating.
+// Each wraps the corresponding `as const` array from tasks-schema.ts,
+// status-registry.ts, or brain-schema.ts.
+
+// --- Task enums ---
+/** Zod enum schema for task statuses. */
+export const taskStatusSchema = z.enum(TASK_STATUSES);
+/** Zod enum schema for task priorities. */
+export const taskPrioritySchema = z.enum(TASK_PRIORITIES);
+/** Zod enum schema for task types. */
+export const taskTypeSchema = z.enum(TASK_TYPES);
+/** Zod enum schema for task sizes. */
+export const taskSizeSchema = z.enum(TASK_SIZES);
+
+// --- Session enums ---
+/** Zod enum schema for session statuses. */
+export const sessionStatusSchema = z.enum(SESSION_STATUSES);
+
+// --- Lifecycle enums ---
+/** Zod enum schema for lifecycle pipeline statuses. */
+export const lifecyclePipelineStatusSchema = z.enum(LIFECYCLE_PIPELINE_STATUSES);
+/** Zod enum schema for lifecycle stage statuses. */
+export const lifecycleStageStatusSchema = z.enum(LIFECYCLE_STAGE_STATUSES);
+/** Zod enum schema for lifecycle stage names. */
+export const lifecycleStageNameSchema = z.enum(LIFECYCLE_STAGE_NAMES);
+/** Zod enum schema for lifecycle gate results. */
+export const lifecycleGateResultSchema = z.enum(LIFECYCLE_GATE_RESULTS);
+/** Zod enum schema for lifecycle evidence types. */
+export const lifecycleEvidenceTypeSchema = z.enum(LIFECYCLE_EVIDENCE_TYPES);
+
+// --- Governance enums ---
+/** Zod enum schema for ADR statuses. */
+export const adrStatusSchema = z.enum(ADR_STATUSES);
+/** Zod enum schema for gate statuses. */
+export const gateStatusSchema = z.enum(GATE_STATUSES);
+/** Zod enum schema for manifest statuses. */
+export const manifestStatusSchema = z.enum(MANIFEST_STATUSES);
+
+// --- Token usage enums ---
+/** Zod enum schema for token usage measurement methods. */
+export const tokenUsageMethodSchema = z.enum(TOKEN_USAGE_METHODS);
+/** Zod enum schema for token usage confidence levels. */
+export const tokenUsageConfidenceSchema = z.enum(TOKEN_USAGE_CONFIDENCE);
+/** Zod enum schema for token usage transports. */
+export const tokenUsageTransportSchema = z.enum(TOKEN_USAGE_TRANSPORTS);
+
+// --- Task relation enums ---
+/** Zod enum schema for task relation types. */
+export const taskRelationTypeSchema = z.enum(TASK_RELATION_TYPES);
+
+// --- External task link enums ---
+/** Zod enum schema for external task link types. */
+export const externalLinkTypeSchema = z.enum(EXTERNAL_LINK_TYPES);
+/** Zod enum schema for sync directions. */
+export const syncDirectionSchema = z.enum(SYNC_DIRECTIONS);
+
+// --- Lifecycle transition enums ---
+/** Zod enum schema for lifecycle transition types. */
+export const lifecycleTransitionTypeSchema = z.enum(LIFECYCLE_TRANSITION_TYPES);
+
+// --- Brain enums ---
+/** Zod enum schema for brain observation types. */
+export const brainObservationTypeSchema = z.enum(BRAIN_OBSERVATION_TYPES);
+/** Zod enum schema for brain observation source types. */
+export const brainObservationSourceTypeSchema = z.enum(BRAIN_OBSERVATION_SOURCE_TYPES);
+/** Zod enum schema for brain decision types. */
+export const brainDecisionTypeSchema = z.enum(BRAIN_DECISION_TYPES);
+/** Zod enum schema for brain confidence levels. */
+export const brainConfidenceLevelSchema = z.enum(BRAIN_CONFIDENCE_LEVELS);
+/** Zod enum schema for brain outcome types. */
+export const brainOutcomeTypeSchema = z.enum(BRAIN_OUTCOME_TYPES);
+/** Zod enum schema for brain pattern types. */
+export const brainPatternTypeSchema = z.enum(BRAIN_PATTERN_TYPES);
+/** Zod enum schema for brain impact levels. */
+export const brainImpactLevelSchema = z.enum(BRAIN_IMPACT_LEVELS);
+/** Zod enum schema for brain link types. */
+export const brainLinkTypeSchema = z.enum(BRAIN_LINK_TYPES);
+/** Zod enum schema for brain memory entity types. */
+export const brainMemoryTypeSchema = z.enum(BRAIN_MEMORY_TYPES);
+/** Zod enum schema for brain sticky note statuses. */
+export const brainStickyStatusSchema = z.enum(BRAIN_STICKY_STATUSES);
+/** Zod enum schema for brain sticky note colors. */
+export const brainStickyColorSchema = z.enum(BRAIN_STICKY_COLORS);
+/** Zod enum schema for brain sticky note priorities. */
+export const brainStickyPrioritySchema = z.enum(BRAIN_STICKY_PRIORITIES);
+/** Zod enum schema for brain page node types. */
+export const brainNodeTypeSchema = z.enum(BRAIN_NODE_TYPES);
+/** Zod enum schema for brain page edge types. */
+export const brainEdgeTypeSchema = z.enum(BRAIN_EDGE_TYPES);
+
+// =========================================================================
+// DRIZZLE-DERIVED INSERT/SELECT SCHEMAS WITH BUSINESS LOGIC REFINEMENTS
+// =========================================================================
+
 // === TASKS ===
 
 /** Task field refinements matching schema-validator.ts constraints. */
@@ -57,13 +208,23 @@ export const selectTaskDependencySchema = createSelectSchema(taskDependencies);
 
 // === TASK RELATIONS ===
 
-export const insertTaskRelationSchema = createInsertSchema(taskRelations);
-export const selectTaskRelationSchema = createSelectSchema(taskRelations);
+/** Task relation refinements — enforce enum values for relation_type. */
+const taskRelationRefinements = {
+  reason: (s: z.ZodString) => s.max(500),
+};
+
+export const insertTaskRelationSchema = createInsertSchema(taskRelations, taskRelationRefinements);
+export const selectTaskRelationSchema = createSelectSchema(taskRelations, taskRelationRefinements);
 
 // === SESSIONS ===
 
-export const insertSessionSchema = createInsertSchema(sessions);
-export const selectSessionSchema = createSelectSchema(sessions);
+/** Session refinements — name constraints and timestamp validation. */
+const sessionRefinements = {
+  name: (s: z.ZodString) => s.min(1).max(200),
+};
+
+export const insertSessionSchema = createInsertSchema(sessions, sessionRefinements);
+export const selectSessionSchema = createSelectSchema(sessions, sessionRefinements);
 
 // Session domain types (Session, SessionScope, SessionStats, SessionTaskWork)
 // are defined in @cleocode/contracts — the single source of truth.
@@ -77,18 +238,60 @@ export const selectWorkHistorySchema = createSelectSchema(taskWorkHistory);
 
 // === LIFECYCLE PIPELINES ===
 
-export const insertLifecyclePipelineSchema = createInsertSchema(lifecyclePipelines);
-export const selectLifecyclePipelineSchema = createSelectSchema(lifecyclePipelines);
+/** Lifecycle pipeline refinements — status and timestamp constraints. */
+const lifecyclePipelineRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  taskId: (s: z.ZodString) => s.min(1),
+};
+
+export const insertLifecyclePipelineSchema = createInsertSchema(
+  lifecyclePipelines,
+  lifecyclePipelineRefinements,
+);
+export const selectLifecyclePipelineSchema = createSelectSchema(
+  lifecyclePipelines,
+  lifecyclePipelineRefinements,
+);
 
 // === LIFECYCLE STAGES ===
 
-export const insertLifecycleStageSchema = createInsertSchema(lifecycleStages);
-export const selectLifecycleStageSchema = createSelectSchema(lifecycleStages);
+/** Lifecycle stage refinements — sequence must be non-negative. */
+const lifecycleStageRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  pipelineId: (s: z.ZodString) => s.min(1),
+  blockReason: (s: z.ZodString) => s.max(1000),
+  skipReason: (s: z.ZodString) => s.max(1000),
+};
+
+export const insertLifecycleStageSchema = createInsertSchema(
+  lifecycleStages,
+  lifecycleStageRefinements,
+);
+export const selectLifecycleStageSchema = createSelectSchema(
+  lifecycleStages,
+  lifecycleStageRefinements,
+);
 
 // === LIFECYCLE GATE RESULTS ===
 
-export const insertLifecycleGateResultSchema = createInsertSchema(lifecycleGateResults);
-export const selectLifecycleGateResultSchema = createSelectSchema(lifecycleGateResults);
+/** Lifecycle gate result refinements — gate name and checker constraints. */
+const lifecycleGateResultRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  stageId: (s: z.ZodString) => s.min(1),
+  gateName: (s: z.ZodString) => s.min(1).max(100),
+  checkedBy: (s: z.ZodString) => s.min(1).max(100),
+  details: (s: z.ZodString) => s.max(2000),
+  reason: (s: z.ZodString) => s.max(1000),
+};
+
+export const insertLifecycleGateResultSchema = createInsertSchema(
+  lifecycleGateResults,
+  lifecycleGateResultRefinements,
+);
+export const selectLifecycleGateResultSchema = createSelectSchema(
+  lifecycleGateResults,
+  lifecycleGateResultRefinements,
+);
 
 // === LIFECYCLE EVIDENCE ===
 
@@ -136,10 +339,126 @@ export const AuditLogSelectSchema = selectAuditLogSchema;
 
 // === ARCHITECTURE DECISIONS ===
 
-export const insertArchitectureDecisionSchema = createInsertSchema(architectureDecisions);
-export const selectArchitectureDecisionSchema = createSelectSchema(architectureDecisions);
+/** Architecture decision refinements — title length and content constraints. */
+const architectureDecisionRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  title: (s: z.ZodString) => s.min(1).max(200),
+  content: (s: z.ZodString) => s.min(1),
+  summary: (s: z.ZodString) => s.max(500),
+};
+
+export const insertArchitectureDecisionSchema = createInsertSchema(
+  architectureDecisions,
+  architectureDecisionRefinements,
+);
+export const selectArchitectureDecisionSchema = createSelectSchema(
+  architectureDecisions,
+  architectureDecisionRefinements,
+);
+
+// === TOKEN USAGE ===
+
+/** Token usage refinements — enforce non-negative token counts. */
+const tokenUsageRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  provider: (s: z.ZodString) => s.min(1).max(100),
+  model: (s: z.ZodString) => s.max(200),
+};
+
+export const insertTokenUsageSchema = createInsertSchema(tokenUsage, tokenUsageRefinements);
+export const selectTokenUsageSchema = createSelectSchema(tokenUsage, tokenUsageRefinements);
+
+// === MANIFEST ENTRIES ===
+
+export const insertManifestEntrySchema = createInsertSchema(manifestEntries);
+export const selectManifestEntrySchema = createSelectSchema(manifestEntries);
+
+// === PIPELINE MANIFEST ===
+
+/** Pipeline manifest refinements — type and content constraints. */
+const pipelineManifestRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  type: (s: z.ZodString) => s.min(1).max(100),
+  content: (s: z.ZodString) => s.min(1),
+};
 
-// === INFERRED TYPES ===
+export const insertPipelineManifestSchema = createInsertSchema(
+  pipelineManifest,
+  pipelineManifestRefinements,
+);
+export const selectPipelineManifestSchema = createSelectSchema(
+  pipelineManifest,
+  pipelineManifestRefinements,
+);
+
+// === RELEASE MANIFESTS ===
+
+/** Release manifest refinements — semver format for version. */
+const releaseManifestRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  version: (s: z.ZodString) => s.regex(/^\d{4}\.\d+\.\d+$|^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/),
+};
+
+export const insertReleaseManifestSchema = createInsertSchema(
+  releaseManifests,
+  releaseManifestRefinements,
+);
+export const selectReleaseManifestSchema = createSelectSchema(
+  releaseManifests,
+  releaseManifestRefinements,
+);
+
+// === EXTERNAL TASK LINKS ===
+
+/** External task link refinements — URL format and field length constraints. */
+const externalTaskLinkRefinements = {
+  id: (s: z.ZodString) => s.min(1),
+  taskId: (s: z.ZodString) => s.min(1),
+  providerId: (s: z.ZodString) => s.min(1).max(100),
+  externalId: (s: z.ZodString) => s.min(1),
+  externalUrl: (s: z.ZodString) => s.url(),
+  externalTitle: (s: z.ZodString) => s.max(500),
+};
+
+export const insertExternalTaskLinkSchema = createInsertSchema(
+  externalTaskLinks,
+  externalTaskLinkRefinements,
+);
+export const selectExternalTaskLinkSchema = createSelectSchema(
+  externalTaskLinks,
+  externalTaskLinkRefinements,
+);
+
+// === AGENT INSTANCES ===
+
+/** Agent instance refinements — ID format and metadata constraints. */
+const agentInstanceRefinements = {
+  id: (s: z.ZodString) => s.regex(/^agt_\d{14}_[0-9a-f]{6}$/),
+};
+
+export const insertAgentInstanceSchema = createInsertSchema(
+  agentInstances,
+  agentInstanceRefinements,
+);
+export const selectAgentInstanceSchema = createSelectSchema(
+  agentInstances,
+  agentInstanceRefinements,
+);
+
+// === AGENT ERROR LOG ===
+
+export const insertAgentErrorLogSchema = createInsertSchema(agentErrorLog);
+export const selectAgentErrorLogSchema = createSelectSchema(agentErrorLog);
+
+// --- Agent enums ---
+/** Zod enum schema for agent instance statuses. */
+export const agentInstanceStatusSchema = z.enum(AGENT_INSTANCE_STATUSES);
+/** Zod enum schema for agent types. */
+export const agentTypeSchema = z.enum(AGENT_TYPES);
+
+// =========================================================================
+// INFERRED TYPES
+// =========================================================================
 
 export type InsertTask = z.infer<typeof insertTaskSchema>;
 export type SelectTask = z.infer<typeof selectTaskSchema>;
@@ -182,21 +501,26 @@ export type AuditLogInsert = InsertAuditLog;
 /** Canonical type alias for audit log select (T4848). */
 export type AuditLogSelect = SelectAuditLog;
 
-// === TOKEN USAGE ===
-
-export const insertTokenUsageSchema = createInsertSchema(tokenUsage);
-export const selectTokenUsageSchema = createSelectSchema(tokenUsage);
-
 export type InsertTokenUsage = z.infer<typeof insertTokenUsageSchema>;
 export type SelectTokenUsage = z.infer<typeof selectTokenUsageSchema>;
 
 export type InsertArchitectureDecision = z.infer<typeof insertArchitectureDecisionSchema>;
 export type SelectArchitectureDecision = z.infer<typeof selectArchitectureDecisionSchema>;
 
-// === MANIFEST ENTRIES ===
-
-export const insertManifestEntrySchema = createInsertSchema(manifestEntries);
-export const selectManifestEntrySchema = createSelectSchema(manifestEntries);
-
 export type InsertManifestEntry = z.infer<typeof insertManifestEntrySchema>;
 export type SelectManifestEntry = z.infer<typeof selectManifestEntrySchema>;
+
+export type InsertPipelineManifest = z.infer<typeof insertPipelineManifestSchema>;
+export type SelectPipelineManifest = z.infer<typeof selectPipelineManifestSchema>;
+
+export type InsertReleaseManifest = z.infer<typeof insertReleaseManifestSchema>;
+export type SelectReleaseManifest = z.infer<typeof selectReleaseManifestSchema>;
+
+export type InsertExternalTaskLink = z.infer<typeof insertExternalTaskLinkSchema>;
+export type SelectExternalTaskLink = z.infer<typeof selectExternalTaskLinkSchema>;
+
+export type InsertAgentInstance = z.infer<typeof insertAgentInstanceSchema>;
+export type SelectAgentInstance = z.infer<typeof selectAgentInstanceSchema>;
+
+export type InsertAgentErrorLog = z.infer<typeof insertAgentErrorLogSchema>;
+export type SelectAgentErrorLog = z.infer<typeof selectAgentErrorLogSchema>;

package/src/system/inject-generate.ts

@@ -5,7 +5,6 @@
 
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { getSessionsPath } from '../paths.js';
 import type { DataAccessor } from '../store/data-accessor.js';
 import { getAccessor } from '../store/data-accessor.js';
 
@@ -15,14 +14,6 @@ export interface InjectGenerateResult {
   version: string;
 }
 
-interface SessionLike {
-  id: string;
-  status: string;
-  name?: string;
-  scope?: { type: string; rootTaskId?: string };
-  taskWork?: { taskId?: string | null };
-}
-
 /** Generate Minimum Viable Injection (MVI) markdown. */
 export async function generateInjection(
   projectRoot: string,
@@ -46,7 +37,7 @@ export async function generateInjection(
   let sessionScope: string | null = null;
 
   const acc = accessor ?? (await getAccessor(projectRoot));
-  const focusMeta = await acc.getMetaValue<{ currentTask?: string }>('focus');
+  const focusMeta = await acc.getMetaValue<{ currentTask?: string | null }>('focus_state');
   const activeSessionMeta = await acc.getMetaValue<string>('activeSession');
 
   if (focusMeta) {
@@ -56,22 +47,17 @@ export async function generateInjection(
     activeSessionName = activeSessionMeta;
   }
 
-  // Try sessions.json for richer session data
+  // Load active session from SQLite (ADR-006/ADR-020)
   try {
-    const sessionsPath = getSessionsPath(projectRoot);
-    if (existsSync(sessionsPath)) {
-      const sessionsData = JSON.parse(readFileSync(sessionsPath, 'utf-8')) as {
-        sessions: SessionLike[];
-      };
-      const active = sessionsData.sessions?.find((s) => s.status === 'active');
-      if (active) {
-        activeSessionName = active.name || active.id;
-        focusTask = active.taskWork?.taskId ?? focusTask;
-        sessionScope = `${active.scope?.type}:${active.scope?.rootTaskId}`;
-      }
+    const sessions = await acc.loadSessions();
+    const active = sessions.find((s) => s.status === 'active');
+    if (active) {
+      activeSessionName = active.name || active.id;
+      focusTask = active.taskWork?.taskId ?? focusTask;
+      sessionScope = `${active.scope?.type}:${active.scope?.rootTaskId}`;
     }
   } catch {
-    // fallback to task data
+    // fallback to meta-only data
   }
 
   // Storage engine is always sqlite (ADR-006)

package/src/validation/doctor/checks.ts

@@ -414,9 +414,26 @@ export function checkCleoGitignore(projectRoot?: string): CheckResult {
 
 /**
  * Detect the storage engine from project config.
- * Per ADR-006, always returns 'sqlite'.
+ *
+ * Per ADR-006, SQLite is the only supported storage engine. This function
+ * checks the project's .cleo/config.json for an explicit storageEngine
+ * override (for forward compatibility) but defaults to 'sqlite'.
+ *
+ * The projectRoot parameter is used to locate the project-level config.
  */
-function detectStorageEngine(_projectRoot: string): string {
+function detectStorageEngine(projectRoot: string): string {
+  const configPath = join(projectRoot, '.cleo', 'config.json');
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (typeof config.storageEngine === 'string' && config.storageEngine) {
+        return config.storageEngine;
+      }
+    } catch {
+      // Invalid config; fall through to default
+    }
+  }
+  // ADR-006: SQLite is the canonical and only supported storage engine
   return 'sqlite';
 }
 
@@ -968,6 +985,11 @@ export function checkNodeVersion(): CheckResult {
 /**
  * Check that global schemas at ~/.cleo/schemas/ are installed and not stale.
  * Delegates to checkGlobalSchemas() from schema-management.ts.
+ *
+ * The projectRoot parameter exists for API consistency with other check
+ * functions in runAllGlobalChecks(), but global schemas live at ~/.cleo/schemas/
+ * (not per-project). The parameter is intentionally unused because schema
+ * health is a system-wide concern, not project-scoped.
  */
 export function checkGlobalSchemaHealth(_projectRoot?: string): CheckResult {
   try {

package/src/validation/engine.ts

@@ -559,7 +559,8 @@ export interface Task {
   [key: string]: unknown;
 }
 
-export interface TaskFile {
+/** Task data shape for validation functions. */
+export interface TaskData {
   tasks: Task[];
   project?: {
     currentPhase?: string;
@@ -572,19 +573,18 @@ export interface TaskFile {
       }
     >;
   };
-  [key: string]: unknown;
 }
 
-export interface ArchiveFile {
+/** Archive data shape for validation functions. */
+export interface ArchiveData {
   archived_tasks: Task[];
-  [key: string]: unknown;
 }
 
 /**
  * Check ID uniqueness within and across files.
  * @task T4523
  */
-export function checkIdUniqueness(taskFile: TaskFile, archiveFile?: ArchiveFile): ValidationResult {
+export function checkIdUniqueness(taskFile: TaskData, archiveFile?: ArchiveData): ValidationResult {
   const errors: ValidationError[] = [];
 
   const taskIds = taskFile.tasks.map((t) => t.id).filter((id): id is string => !!id);
@@ -822,7 +822,7 @@ export function validateNoCircularDeps(
  * Validate only one phase is active.
  * @task T4523
  */
-export function validateSingleActivePhase(taskFile: TaskFile): ValidationResult {
+export function validateSingleActivePhase(taskFile: TaskData): ValidationResult {
   const phases = taskFile.project?.phases;
   if (!phases) return { valid: true, errors: [], warnings: [] };
 
@@ -849,7 +849,7 @@ export function validateSingleActivePhase(taskFile: TaskFile): ValidationResult
  * Validate currentPhase matches an active phase.
  * @task T4523
  */
-export function validateCurrentPhaseConsistency(taskFile: TaskFile): ValidationResult {
+export function validateCurrentPhaseConsistency(taskFile: TaskData): ValidationResult {
   const currentPhase = taskFile.project?.currentPhase;
   if (!currentPhase) return { valid: true, errors: [], warnings: [] };
 
@@ -892,7 +892,7 @@ export function validateCurrentPhaseConsistency(taskFile: TaskFile): ValidationR
  * Validate phase timestamp ordering.
  * @task T4523
  */
-export function validatePhaseTimestamps(taskFile: TaskFile): ValidationResult {
+export function validatePhaseTimestamps(taskFile: TaskData): ValidationResult {
   const phases = taskFile.project?.phases;
   if (!phases) return { valid: true, errors: [], warnings: [] };
 
@@ -917,7 +917,7 @@ export function validatePhaseTimestamps(taskFile: TaskFile): ValidationResult {
  * Validate phase status requirements (e.g., active phases must have startedAt).
  * @task T4523
  */
-export function validatePhaseStatusRequirements(taskFile: TaskFile): ValidationResult {
+export function validatePhaseStatusRequirements(taskFile: TaskData): ValidationResult {
   const phases = taskFile.project?.phases;
   if (!phases) return { valid: true, errors: [], warnings: [] };
 
@@ -962,8 +962,8 @@ export interface ComprehensiveValidationResult {
  * @task T4523
  */
 export function validateAll(
-  taskFile: TaskFile,
-  archiveFile?: ArchiveFile,
+  taskFile: TaskData,
+  archiveFile?: ArchiveData,
 ): ComprehensiveValidationResult {
   let schemaErrors = 0;
   let semanticErrors = 0;