@cleocode/core 2026.4.2 → 2026.4.3

package/dist/index.js

@@ -22134,7 +22134,7 @@ async function endSession(options = {}, cwd, accessor) {
   session.endedAt = (/* @__PURE__ */ new Date()).toISOString();
   const duration3 = Math.floor((Date.now() - new Date(session.startedAt).getTime()) / 1e3);
   const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  hooks2.dispatch("SessionEnd", cwd ?? process.cwd(), {
+  await hooks2.dispatch("SessionEnd", cwd ?? process.cwd(), {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: session.id,
     duration: duration3,
@@ -22143,7 +22143,7 @@ async function endSession(options = {}, cwd, accessor) {
   }).catch(() => {
   });
   const { bridgeSessionToMemory: bridgeSessionToMemory2 } = await Promise.resolve().then(() => (init_session_memory_bridge(), session_memory_bridge_exports));
-  bridgeSessionToMemory2(cwd ?? process.cwd(), {
+  await bridgeSessionToMemory2(cwd ?? process.cwd(), {
     sessionId: session.id,
     scope: options.sessionId ? session.scope.type : session.scope.epicId ? `epic:${session.scope.epicId}` : session.scope.type,
     tasksCompleted: session.tasksCompleted || [],
@@ -22156,6 +22156,11 @@ async function endSession(options = {}, cwd, accessor) {
   }
   const acc = accessor ?? await getAccessor(cwd);
   await acc.upsertSingleSession(session);
+  try {
+    const { refreshMemoryBridge: refreshMemoryBridge2 } = await Promise.resolve().then(() => (init_memory_bridge(), memory_bridge_exports));
+    await refreshMemoryBridge2(cwd ?? process.cwd());
+  } catch {
+  }
   return session;
 }
 async function sessionStatus(cwd, accessor) {
@@ -26897,6 +26902,208 @@ var init_complete = __esm({
   }
 });
 
+// packages/core/src/validation/validation-rules.ts
+var validation_rules_exports = {};
+__export(validation_rules_exports, {
+  hasErrors: () => hasErrors,
+  validateHierarchy: () => validateHierarchy,
+  validateIdUniqueness: () => validateIdUniqueness,
+  validateNewTask: () => validateNewTask,
+  validateNoDuplicateDescription: () => validateNoDuplicateDescription,
+  validateStatusTransition: () => validateStatusTransition,
+  validateTimestamps: () => validateTimestamps,
+  validateTitleDescription: () => validateTitleDescription
+});
+function validateTitleDescription(title, description) {
+  const violations = [];
+  if (!title || title.trim().length === 0) {
+    violations.push({
+      rule: "title-required",
+      field: "title",
+      message: "Title is required and cannot be empty",
+      severity: "error"
+    });
+  }
+  if (!description || description.trim().length === 0) {
+    violations.push({
+      rule: "description-required",
+      field: "description",
+      message: "Description is required and cannot be empty",
+      severity: "error"
+    });
+  }
+  if (title && description && title.trim().toLowerCase() === description.trim().toLowerCase()) {
+    violations.push({
+      rule: "title-description-different",
+      field: "description",
+      message: "Title and description must be different",
+      severity: "error"
+    });
+  }
+  return violations;
+}
+function validateTimestamps(task) {
+  const violations = [];
+  const now = /* @__PURE__ */ new Date();
+  const threshold = new Date(now.getTime() + 5 * 60 * 1e3);
+  const timestampFields = [
+    ["createdAt", task.createdAt],
+    ["updatedAt", task.updatedAt],
+    ["completedAt", task.completedAt],
+    ["cancelledAt", task.cancelledAt]
+  ];
+  for (const [field, value] of timestampFields) {
+    if (value) {
+      const date6 = new Date(value);
+      if (Number.isNaN(date6.getTime())) {
+        violations.push({
+          rule: "valid-timestamp",
+          field,
+          message: `Invalid timestamp format: ${value}`,
+          severity: "error"
+        });
+      } else if (date6 > threshold) {
+        violations.push({
+          rule: "no-future-timestamps",
+          field,
+          message: `Timestamp ${value} is in the future`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return violations;
+}
+function validateIdUniqueness(taskId, existingIds) {
+  if (existingIds.has(taskId)) {
+    return [
+      {
+        rule: "unique-id",
+        field: "id",
+        message: `Task ID '${taskId}' already exists`,
+        severity: "error"
+      }
+    ];
+  }
+  return [];
+}
+function validateNoDuplicateDescription(description, existingDescriptions, _excludeTaskId) {
+  const normalizedNew = description.trim().toLowerCase();
+  for (const existing of existingDescriptions) {
+    if (existing.trim().toLowerCase() === normalizedNew) {
+      return [
+        {
+          rule: "no-duplicate-description",
+          field: "description",
+          message: "A task with this exact description already exists",
+          severity: "warning"
+        }
+      ];
+    }
+  }
+  return [];
+}
+function validateHierarchy(parentId, tasks2, _taskType, limits) {
+  const violations = [];
+  if (!parentId) {
+    return violations;
+  }
+  const maxDepth = limits?.maxDepth ?? 3;
+  const maxSiblings = limits?.maxSiblings ?? 0;
+  const parent = tasks2.find((t) => t.id === parentId);
+  if (!parent) {
+    violations.push({
+      rule: "parent-exists",
+      field: "parentId",
+      message: `Parent task '${parentId}' not found`,
+      severity: "error"
+    });
+    return violations;
+  }
+  let depth = 1;
+  let current = parent;
+  while (current.parentId) {
+    depth++;
+    const nextParent = tasks2.find((t) => t.id === current.parentId);
+    if (!nextParent) break;
+    current = nextParent;
+  }
+  if (depth > maxDepth - 1) {
+    violations.push({
+      rule: "max-depth",
+      field: "parentId",
+      message: `Maximum hierarchy depth of ${maxDepth} exceeded (epic -> task -> subtask)`,
+      severity: "error"
+    });
+  }
+  const siblingCount = tasks2.filter((t) => t.parentId === parentId).length;
+  if (maxSiblings > 0 && siblingCount >= maxSiblings) {
+    violations.push({
+      rule: "max-siblings",
+      field: "parentId",
+      message: `Parent '${parentId}' already has ${siblingCount} children (max ${maxSiblings})`,
+      severity: "error"
+    });
+  }
+  return violations;
+}
+function validateStatusTransition(currentStatus, newStatus) {
+  const validTransitions = {
+    pending: ["active", "blocked", "done", "cancelled"],
+    active: ["pending", "blocked", "done", "cancelled"],
+    blocked: ["pending", "active", "done", "cancelled"],
+    done: ["pending", "active"],
+    // restore (alias: reopen)
+    cancelled: ["pending"]
+    // restore (alias: uncancel)
+  };
+  const allowed = validTransitions[currentStatus];
+  if (!allowed) {
+    return [
+      {
+        rule: "valid-status-transition",
+        field: "status",
+        message: `Unknown current status: '${currentStatus}'`,
+        severity: "error"
+      }
+    ];
+  }
+  if (!allowed.includes(newStatus)) {
+    return [
+      {
+        rule: "valid-status-transition",
+        field: "status",
+        message: `Cannot transition from '${currentStatus}' to '${newStatus}'. Valid: ${allowed.join(", ")}`,
+        severity: "error"
+      }
+    ];
+  }
+  return [];
+}
+function validateNewTask(task, existingIds, existingDescriptions, existingTasks, limits) {
+  const violations = [];
+  violations.push(...validateTitleDescription(task.title, task.description));
+  violations.push(...validateTimestamps(task));
+  if (task.id) {
+    violations.push(...validateIdUniqueness(task.id, existingIds));
+  }
+  if (task.description) {
+    violations.push(...validateNoDuplicateDescription(task.description, existingDescriptions));
+  }
+  if (task.parentId) {
+    violations.push(...validateHierarchy(task.parentId, existingTasks, task.type, limits));
+  }
+  return violations;
+}
+function hasErrors(violations) {
+  return violations.some((v) => v.severity === "error");
+}
+var init_validation_rules = __esm({
+  "packages/core/src/validation/validation-rules.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/tasks/update.ts
 var update_exports = {};
 __export(update_exports, {
@@ -26946,6 +27153,11 @@ async function updateTask(options, cwd, accessor) {
   }
   if (options.status !== void 0) {
     validateStatus(options.status);
+    const { validateStatusTransition: validateStatusTransition3 } = await Promise.resolve().then(() => (init_validation_rules(), validation_rules_exports));
+    const transitionViolations = validateStatusTransition3(task.status, options.status);
+    if (transitionViolations.length > 0) {
+      throw new CleoError(6 /* VALIDATION_ERROR */, transitionViolations[0].message);
+    }
     const oldStatus = task.status;
     task.status = options.status;
     changes.push("status");
@@ -65261,7 +65473,7 @@ __export(validation_exports, {
   validatePhaseTimestamps: () => validatePhaseTimestamps,
   validateSessionNote: () => validateSessionNote,
   validateSingleActivePhase: () => validateSingleActivePhase,
-  validateStatusTransition: () => validateStatusTransition,
+  validateStatusTransition: () => validateStatusTransition2,
   validateTask: () => validateTask,
   validateTitle: () => validateTitle2
 });
@@ -66031,9 +66243,9 @@ function detectDrift(mode = "full", projectRoot = ".") {
       }
     }
   }
-  const hasErrors = issues.some((i) => i.severity === "error");
+  const hasErrors2 = issues.some((i) => i.severity === "error");
   const hasWarnings = issues.some((i) => i.severity === "warning");
-  const exitCode = hasErrors ? 2 : hasWarnings ? 1 : 0;
+  const exitCode = hasErrors2 ? 2 : hasWarnings ? 1 : 0;
   return { mode, issues, exitCode };
 }
 function shouldRunDriftDetection(enabled = true, autoCheck = false, command, criticalCommands = []) {
@@ -66529,7 +66741,7 @@ var STATUS_TRANSITIONS = {
   cancelled: ["pending"],
   archived: []
 };
-function validateStatusTransition(oldStatus, newStatus) {
+function validateStatusTransition2(oldStatus, newStatus) {
   if (oldStatus === newStatus) {
     return { valid: true, errors: [], warnings: [] };
   }