@cleocode/cleo 2026.4.2 → 2026.4.3

package/dist/cli/index.js

@@ -25334,7 +25334,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,
@@ -25343,7 +25343,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 || [],
@@ -25356,6 +25356,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) {
@@ -51528,6 +51533,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 now2 = /* @__PURE__ */ new Date();
+  const threshold = new Date(now2.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, {
@@ -51577,6 +51784,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");
@@ -68579,7 +68791,7 @@ function validateCancelReason(reason) {
   }
   return { valid: errors.length === 0, errors, warnings: [] };
 }
-function validateStatusTransition(oldStatus, newStatus) {
+function validateStatusTransition2(oldStatus, newStatus) {
   if (oldStatus === newStatus) {
     return { valid: true, errors: [], warnings: [] };
   }
@@ -70038,7 +70250,7 @@ __export(validation_exports, {
   validatePhaseTimestamps: () => validatePhaseTimestamps,
   validateSessionNote: () => validateSessionNote,
   validateSingleActivePhase: () => validateSingleActivePhase,
-  validateStatusTransition: () => validateStatusTransition,
+  validateStatusTransition: () => validateStatusTransition2,
   validateTask: () => validateTask,
   validateTitle: () => validateTitle2
 });
@@ -72085,6 +72297,7 @@ __export(src_exports, {
 });
 var init_src2 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -81574,149 +81787,6 @@ var init_schema_validator = __esm({
   }
 });
 
-// packages/core/src/validation/validation-rules.ts
-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 now2 = /* @__PURE__ */ new Date();
-  const threshold = new Date(now2.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 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/validation/validate-ops.ts
 import { execFileSync as execFileSync12 } from "node:child_process";
 import { appendFileSync as appendFileSync10, existsSync as existsSync120, mkdirSync as mkdirSync25, readFileSync as readFileSync91 } from "node:fs";
@@ -83588,6 +83658,7 @@ __export(internal_exports, {
   getOtelSummary: () => getOtelSummary,
   getPackageRoot: () => getPackageRoot,
   getParallelStatus: () => getParallelStatus,
+  getPipelineStageOrder: () => getPipelineStageOrder,
   getProjectInfo: () => getProjectInfo,
   getProjectInfoSync: () => getProjectInfoSync,
   getProjectRoot: () => getProjectRoot,
@@ -83667,6 +83738,7 @@ __export(internal_exports, {
   isLafsSuccess: () => isLafsSuccess,
   isNoChangeCode: () => isNoChangeCode,
   isOverloaded: () => isOverloaded,
+  isPipelineTransitionForward: () => isPipelineTransitionForward,
   isProjectInitialized: () => isProjectInitialized,
   isProviderHookEvent: () => isProviderHookEvent,
   isRecoverableCode: () => isRecoverableCode,
@@ -84064,6 +84136,7 @@ var init_internal = __esm({
     init_add();
     init_graph_ops();
     init_list3();
+    init_pipeline_stage();
     init_relates();
     init_task_ops();
     init_parser2();
@@ -88670,6 +88743,19 @@ async function lifecycleProgress(taskId, stage, status, notes, projectRoot) {
   }
   try {
     if (status === "in_progress" || status === "completed") {
+      const { getLifecycleStatus: getLifecycleStatus2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      const current = await getLifecycleStatus2(taskId, projectRoot);
+      if (current.currentStage) {
+        const { isPipelineTransitionForward: isPipelineTransitionForward2, getPipelineStageOrder: getPipelineStageOrder2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+        if (!isPipelineTransitionForward2(current.currentStage, stage)) {
+          const currentOrder = getPipelineStageOrder2(current.currentStage);
+          const newOrder = getPipelineStageOrder2(stage);
+          return engineError(
+            "E_LIFECYCLE_BACKWARD",
+            `Cannot move backward from "${current.currentStage}" (stage ${currentOrder}) to "${stage}" (stage ${newOrder}). Pipeline stages are forward-only.`
+          );
+        }
+      }
       const gateResult = await checkGate(taskId, stage, projectRoot);
       if (!gateResult.allowed) {
         return engineError("E_LIFECYCLE_GATE_FAILED", gateResult.message);
@@ -92088,14 +92174,28 @@ function initVerification2() {
     failureLog: []
   };
 }
-function computePassed2(verification) {
-  for (const gate of DEFAULT_REQUIRED_GATES2) {
+function computePassed2(verification, requiredGates = DEFAULT_REQUIRED_GATES2) {
+  for (const gate of requiredGates) {
     if (verification.gates[gate] !== true) return false;
   }
   return true;
 }
-function getMissingGates2(verification) {
-  return DEFAULT_REQUIRED_GATES2.filter((g) => verification.gates[g] !== true);
+function getMissingGates2(verification, requiredGates = DEFAULT_REQUIRED_GATES2) {
+  return requiredGates.filter((g) => verification.gates[g] !== true);
+}
+async function loadRequiredGates(projectRoot) {
+  try {
+    const { loadConfig: loadConfig4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+    const config2 = await loadConfig4(projectRoot);
+    const cfgGates = config2.verification?.requiredGates;
+    if (Array.isArray(cfgGates) && cfgGates.length > 0) {
+      return cfgGates.filter(
+        (g) => DEFAULT_REQUIRED_GATES2.includes(g)
+      );
+    }
+  } catch {
+  }
+  return [...DEFAULT_REQUIRED_GATES2];
 }
 async function validateGateVerify(params, projectRoot) {
   try {
@@ -92110,9 +92210,10 @@ async function validateGateVerify(params, projectRoot) {
     if (!task) {
       return engineError("E_NOT_FOUND", `Task ${taskId} not found`);
     }
+    const configGates = await loadRequiredGates(root);
     if (!gate && !all && !reset) {
       const verification2 = task.verification ?? initVerification2();
-      const missing2 = getMissingGates2(verification2);
+      const missing2 = getMissingGates2(verification2, configGates);
       return {
         success: true,
         data: {
@@ -92124,7 +92225,7 @@ async function validateGateVerify(params, projectRoot) {
           verificationStatus: verification2.passed ? "passed" : "pending",
           passed: verification2.passed,
           round: verification2.round,
-          requiredGates: DEFAULT_REQUIRED_GATES2,
+          requiredGates: configGates,
           missingGates: missing2,
           action: "view"
         }
@@ -92137,7 +92238,7 @@ async function validateGateVerify(params, projectRoot) {
       verification = initVerification2();
       action = "reset";
     } else if (all) {
-      for (const g of DEFAULT_REQUIRED_GATES2) {
+      for (const g of configGates) {
         verification.gates[g] = true;
       }
       if (agent) {
@@ -92168,11 +92269,11 @@ async function validateGateVerify(params, projectRoot) {
       }
       action = "set_gate";
     }
-    verification.passed = computePassed2(verification);
+    verification.passed = computePassed2(verification, configGates);
     task.verification = verification;
     task.updatedAt = now2;
     await accessor.upsertSingleTask(task);
-    const missing = getMissingGates2(verification);
+    const missing = getMissingGates2(verification, configGates);
     const result = {
       taskId,
       title: task.title,
@@ -92182,14 +92283,14 @@ async function validateGateVerify(params, projectRoot) {
       verificationStatus: verification.passed ? "passed" : "pending",
       passed: verification.passed,
       round: verification.round,
-      requiredGates: DEFAULT_REQUIRED_GATES2,
+      requiredGates: configGates,
       missingGates: missing,
       action
     };
     if (action === "set_gate") {
       result.gateSet = gate;
     } else if (action === "set_all") {
-      result.gatesSet = DEFAULT_REQUIRED_GATES2;
+      result.gatesSet = configGates;
     }
     return { success: true, data: result };
   } catch (err) {