@cleocode/core 2026.3.42 → 2026.3.44

package/src/validation/index.ts

@@ -1,7 +1,9 @@
 /**
  * Validation system barrel exports.
  *
- * Provides the complete validation system ported from lib/validation/*.
+ * Provides the complete validation system ported from lib/validation/*,
+ * plus canonical Zod enum schemas for all domain enums so consumers can
+ * import them from `@cleocode/core` instead of duplicating.
  *
  * @task T4523
  * @epic T4454
@@ -9,6 +11,132 @@
 
 // Core validation engine — also re-export registry constants for convenience
 export { TASK_STATUSES } from '@cleocode/contracts';
+// Inferred types
+export type {
+  AuditLogInsert,
+  AuditLogSelect,
+  InsertArchitectureDecision,
+  InsertAuditLog,
+  InsertExternalTaskLink,
+  InsertLifecycleEvidence,
+  InsertLifecycleGateResult,
+  InsertLifecyclePipeline,
+  InsertLifecycleStage,
+  InsertLifecycleTransition,
+  InsertManifestEntry,
+  InsertPipelineManifest,
+  InsertReleaseManifest,
+  InsertSchemaMeta,
+  InsertSession,
+  InsertTask,
+  InsertTaskDependency,
+  InsertTaskRelation,
+  InsertTokenUsage,
+  InsertWorkHistory,
+  SelectArchitectureDecision,
+  SelectAuditLog,
+  SelectExternalTaskLink,
+  SelectLifecycleEvidence,
+  SelectLifecycleGateResult,
+  SelectLifecyclePipeline,
+  SelectLifecycleStage,
+  SelectLifecycleTransition,
+  SelectManifestEntry,
+  SelectPipelineManifest,
+  SelectReleaseManifest,
+  SelectSchemaMeta,
+  SelectSession,
+  SelectTask,
+  SelectTaskDependency,
+  SelectTaskRelation,
+  SelectTokenUsage,
+  SelectWorkHistory,
+} from '../store/validation-schemas.js';
+// ---------------------------------------------------------------------------
+// Canonical Zod enum schemas (from validation-schemas.ts)
+// ---------------------------------------------------------------------------
+// Task enums
+// Session enums
+// Lifecycle enums
+// Governance enums
+// Token usage enums
+// Relation / link enums
+// Brain enums
+// Insert/select schemas for all tables
+export {
+  AuditLogInsertSchema,
+  AuditLogSelectSchema,
+  adrStatusSchema,
+  brainConfidenceLevelSchema,
+  brainDecisionTypeSchema,
+  brainEdgeTypeSchema,
+  brainImpactLevelSchema,
+  brainLinkTypeSchema,
+  brainMemoryTypeSchema,
+  brainNodeTypeSchema,
+  brainObservationSourceTypeSchema,
+  brainObservationTypeSchema,
+  brainOutcomeTypeSchema,
+  brainPatternTypeSchema,
+  brainStickyColorSchema,
+  brainStickyPrioritySchema,
+  brainStickyStatusSchema,
+  externalLinkTypeSchema,
+  gateStatusSchema,
+  insertArchitectureDecisionSchema,
+  insertAuditLogSchema,
+  insertExternalTaskLinkSchema,
+  insertLifecycleEvidenceSchema,
+  insertLifecycleGateResultSchema,
+  insertLifecyclePipelineSchema,
+  insertLifecycleStageSchema,
+  insertLifecycleTransitionSchema,
+  insertManifestEntrySchema,
+  insertPipelineManifestSchema,
+  insertReleaseManifestSchema,
+  insertSchemaMetaSchema,
+  insertSessionSchema,
+  insertTaskDependencySchema,
+  insertTaskRelationSchema,
+  insertTaskSchema,
+  insertTokenUsageSchema,
+  insertWorkHistorySchema,
+  lifecycleEvidenceTypeSchema,
+  lifecycleGateResultSchema,
+  lifecyclePipelineStatusSchema,
+  lifecycleStageNameSchema,
+  lifecycleStageStatusSchema,
+  lifecycleTransitionTypeSchema,
+  manifestStatusSchema,
+  selectArchitectureDecisionSchema,
+  selectAuditLogSchema,
+  selectExternalTaskLinkSchema,
+  selectLifecycleEvidenceSchema,
+  selectLifecycleGateResultSchema,
+  selectLifecyclePipelineSchema,
+  selectLifecycleStageSchema,
+  selectLifecycleTransitionSchema,
+  selectManifestEntrySchema,
+  selectPipelineManifestSchema,
+  selectReleaseManifestSchema,
+  selectSchemaMetaSchema,
+  selectSessionSchema,
+  selectTaskDependencySchema,
+  selectTaskRelationSchema,
+  selectTaskSchema,
+  selectTokenUsageSchema,
+  selectWorkHistorySchema,
+  sessionStatusSchema,
+  syncDirectionSchema,
+  taskPrioritySchema,
+  taskRelationTypeSchema,
+  taskSizeSchema,
+  taskStatusSchema,
+  taskTypeSchema,
+  tokenUsageConfidenceSchema,
+  tokenUsageMethodSchema,
+  tokenUsageTransportSchema,
+} from '../store/validation-schemas.js';
 // Compliance checking
 export {
   type ComplianceMetrics,
@@ -37,7 +165,7 @@ export {
 // Doctor health checks
 export * from './doctor/index.js';
 export {
-  type ArchiveFile,
+  type ArchiveData,
   type ComprehensiveValidationResult,
   checkIdUniqueness,
   checkTimestampSanity,
@@ -47,7 +175,7 @@ export {
   normalizeLabels,
   sanitizeFilePath,
   type Task,
-  type TaskFile,
+  type TaskData,
   type TaskStatus,
   VALID_OPERATIONS,
   type ValidationError,

package/src/validation/protocol-common.ts

@@ -88,16 +88,49 @@ const VALID_TYPES = [
 const VALID_STATUSES_MSG = MANIFEST_STATUSES.filter((s) => s !== 'archived');
 const VALID_DETAILS = ['summary', 'details', 'blocker details'];
 
+/**
+ * Map from protocol type identifiers to the expected message type prefix.
+ * When a protocolType is provided, the return message must use the matching type.
+ */
+const PROTOCOL_TYPE_MAP: Record<string, string> = {
+  research: 'Research',
+  implementation: 'Implementation',
+  validation: 'Validation',
+  testing: 'Testing',
+  specification: 'Specification',
+  consensus: 'Consensus',
+  decomposition: 'Decomposition',
+  contribution: 'Contribution',
+  release: 'Release',
+};
+
 /**
  * Check if return message follows protocol format.
  * Expected: "<Type> <status>. See MANIFEST.jsonl for <detail>."
+ *
+ * When protocolType is provided, the message type must match the protocol
+ * (e.g., a 'research' protocol must produce a "Research ..." message).
+ *
  * @task T4527
  */
-export function checkReturnMessageFormat(message: string, _protocolType?: string): boolean {
-  const typePattern = VALID_TYPES.join('|');
+export function checkReturnMessageFormat(message: string, protocolType?: string): boolean {
   const statusPattern = VALID_STATUSES_MSG.join('|');
   const detailPattern = VALID_DETAILS.join('|');
 
+  // If protocolType is given, constrain the type to the matching prefix
+  let typePattern: string;
+  if (protocolType) {
+    const expectedType = PROTOCOL_TYPE_MAP[protocolType.toLowerCase()];
+    if (!expectedType) {
+      // Unknown protocol type — fall back to allowing any valid type
+      typePattern = VALID_TYPES.join('|');
+    } else {
+      typePattern = expectedType;
+    }
+  } else {
+    typePattern = VALID_TYPES.join('|');
+  }
+
   const regex = new RegExp(
     `^(${typePattern}) (${statusPattern})\\. See MANIFEST\\.jsonl for (${detailPattern})\\.$`,
   );
@@ -217,11 +250,15 @@ export function checkProvenanceTags(filePath: string, taskId?: string): boolean
 
 /**
  * Validate common manifest requirements across all protocols.
+ *
+ * When protocolType is provided, additionally validates that the manifest
+ * entry's agent_type matches the expected protocol type.
+ *
  * @task T4527
  */
 export function validateCommonManifestRequirements(
   entry: Record<string, unknown>,
-  _protocolType?: string,
+  protocolType?: string,
 ): ProtocolValidationResult {
   const violations: ProtocolViolation[] = [];
   let score = 100;
@@ -289,6 +326,20 @@ export function validateCommonManifestRequirements(
     score -= 5;
   }
 
+  // Protocol-specific: verify agent_type matches the protocol when specified
+  if (protocolType && checkManifestFieldPresent(entry, 'agent_type')) {
+    const expectedType = PROTOCOL_TYPE_MAP[protocolType.toLowerCase()];
+    if (expectedType && !checkAgentType(entry, expectedType.toLowerCase())) {
+      violations.push({
+        requirement: 'COMMON-007',
+        severity: 'warning',
+        message: `agent_type '${String(entry['agent_type'])}' does not match protocol '${protocolType}'`,
+        fix: `Set agent_type to '${expectedType.toLowerCase()}'`,
+      });
+      score -= 5;
+    }
+  }
+
   return {
     valid: score >= 70,
     violations,

package/src/tasks/reparent.ts

@@ -1,134 +0,0 @@
-/**
- * Canonical reparent logic — move a task to a different parent in the hierarchy.
- * Both CLI (reparent command) and core (updateTask) delegate here.
- *
- * This module operates on an in-memory TaskFile. The caller is responsible
- * for loading and saving the data (via DataAccessor or direct JSON I/O).
- *
- * @task T4807
- * @epic T4454
- */
-
-import type { TaskFile } from '@cleocode/contracts';
-import { ExitCode } from '@cleocode/contracts';
-import { loadConfig } from '../config.js';
-import { CleoError } from '../errors.js';
-import { getDepth, wouldCreateCircle } from './hierarchy.js';
-import type { HierarchyPolicy } from './hierarchy-policy.js';
-import { resolveHierarchyPolicy, validateHierarchyPlacement } from './hierarchy-policy.js';
-
-/** Options for reparenting a task. */
-export interface ReparentOptions {
-  taskId: string;
-  /** New parent ID, or null to promote to root. */
-  newParentId: string | null;
-  /** Optional resolved hierarchy policy. If not provided, uses llm-agent-first defaults. */
-  policy?: HierarchyPolicy;
-}
-
-/** Result of a reparent operation. */
-export interface ReparentResult {
-  oldParent: string | null;
-  newParent: string | null;
-  newType: string;
-}
-
-/**
- * Reparent a task within a TaskFile.
- *
- * Mutates the task in-place within `data.tasks`. Updates `parentId`, `type`,
- * and `updatedAt` on the target task, and `lastUpdated` on the TaskFile.
- *
- * @param data  The loaded TaskFile (mutated in place)
- * @param opts  Reparent options (taskId, newParentId)
- * @returns     Result with old/new parent and new type
- */
-export async function reparentTask(data: TaskFile, opts: ReparentOptions): Promise<ReparentResult> {
-  const { taskId, newParentId } = opts;
-
-  const task = data.tasks.find((t) => t.id === taskId);
-  if (!task) {
-    throw new CleoError(ExitCode.NOT_FOUND, `Task not found: ${taskId}`, {
-      fix: `Use 'cleo find "${taskId}"' to search`,
-    });
-  }
-
-  const oldParent = task.parentId ?? null;
-  const effectiveNewParent = newParentId || null;
-
-  // Promote to root
-  if (!effectiveNewParent) {
-    task.parentId = null;
-    if (task.type === 'subtask') {
-      task.type = 'task';
-    }
-    task.updatedAt = new Date().toISOString();
-    data.lastUpdated = new Date().toISOString();
-
-    return {
-      oldParent,
-      newParent: null,
-      newType: task.type ?? 'task',
-    };
-  }
-
-  // Validate target parent exists and hierarchy constraints (depth + sibling limits)
-  const effectivePolicy = opts.policy ?? resolveHierarchyPolicy(await loadConfig());
-  const validation = validateHierarchyPlacement(effectiveNewParent, data.tasks, effectivePolicy);
-  if (!validation.valid) {
-    const code =
-      validation.error?.code === 'E_PARENT_NOT_FOUND'
-        ? ExitCode.PARENT_NOT_FOUND
-        : validation.error?.code === 'E_DEPTH_EXCEEDED'
-          ? ExitCode.DEPTH_EXCEEDED
-          : validation.error?.code === 'E_SIBLING_LIMIT'
-            ? ExitCode.SIBLING_LIMIT
-            : ExitCode.INVALID_INPUT;
-
-    throw new CleoError(
-      code,
-      validation.error?.message ?? `Cannot reparent under ${effectiveNewParent}`,
-      { fix: `Check hierarchy constraints with 'cleo show ${effectiveNewParent}'` },
-    );
-  }
-
-  const newParentTask = data.tasks.find((t) => t.id === effectiveNewParent);
-
-  // Cannot parent under a subtask
-  if (newParentTask?.type === 'subtask') {
-    throw new CleoError(
-      ExitCode.INVALID_PARENT_TYPE,
-      `Cannot parent under subtask '${effectiveNewParent}'`,
-      { fix: `Choose a task or epic as the parent instead` },
-    );
-  }
-
-  // Check circular reference
-  if (wouldCreateCircle(taskId, effectiveNewParent, data.tasks)) {
-    throw new CleoError(
-      ExitCode.CIRCULAR_REFERENCE,
-      `Moving '${taskId}' under '${effectiveNewParent}' would create a circular reference`,
-      { fix: `The target parent is a descendant of the task being moved` },
-    );
-  }
-
-  // Apply the reparent
-  task.parentId = effectiveNewParent;
-
-  // Update type based on new depth in the hierarchy
-  const newDepth = getDepth(taskId, data.tasks);
-  if (newDepth === 1) {
-    task.type = 'task';
-  } else if (newDepth >= 2) {
-    task.type = 'subtask';
-  }
-
-  task.updatedAt = new Date().toISOString();
-  data.lastUpdated = new Date().toISOString();
-
-  return {
-    oldParent,
-    newParent: effectiveNewParent,
-    newType: task.type ?? 'task',
-  };
-}