@cleocode/cleo 2026.3.64 → 2026.3.66

package/dist/cli/index.js

@@ -16783,6 +16783,63 @@ var init_health_monitor = __esm({
   }
 });
 
+// packages/core/src/lib/retry.ts
+var retry_exports = {};
+__export(retry_exports, {
+  computeDelay: () => computeDelay,
+  withRetry: () => withRetry
+});
+async function withRetry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const baseDelayMs = options?.baseDelayMs ?? 2e3;
+  const maxDelayMs = options?.maxDelayMs ?? 3e4;
+  const retryableErrors = options?.retryableErrors;
+  let lastError;
+  let totalDelayMs = 0;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isLastAttempt = attempt === maxAttempts;
+      if (isLastAttempt) break;
+      if (retryableErrors !== void 0 && !isRetryable(err, retryableErrors)) break;
+      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
+      totalDelayMs += delay;
+      await sleep(delay);
+    }
+  }
+  const context = { attempts: maxAttempts, totalDelayMs };
+  augmentError(lastError, context);
+  throw lastError;
+}
+function computeDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = baseDelayMs * 2 ** (attempt - 1);
+  return Math.min(exponential, maxDelayMs);
+}
+function isRetryable(err, predicates) {
+  const message = err instanceof Error ? err.message : String(err);
+  return predicates.some((predicate) => {
+    if (predicate instanceof RegExp) return predicate.test(message);
+    return predicate(err);
+  });
+}
+function augmentError(err, context) {
+  if (err instanceof Error) {
+    const mutableErr = err;
+    mutableErr.attempts = context.attempts;
+    mutableErr.totalDelayMs = context.totalDelayMs;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
+var init_retry = __esm({
+  "packages/core/src/lib/retry.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/agents/retry.ts
 function createRetryPolicy(overrides) {
   return { ...DEFAULT_RETRY_POLICY, ...overrides };
@@ -16802,42 +16859,27 @@ function shouldRetry(error40, attempt, policy) {
   if (classification === "retriable") return true;
   return policy.retryOnUnknown;
 }
-async function withRetry(fn, policy) {
+async function withRetry2(fn, policy) {
   const effectivePolicy = createRetryPolicy(policy);
-  let lastError;
-  let totalDelayMs = 0;
-  for (let attempt = 0; attempt <= effectivePolicy.maxRetries; attempt++) {
-    try {
-      const value = await fn();
-      return {
-        success: true,
-        value,
-        attempts: attempt + 1,
-        totalDelayMs
-      };
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      if (!shouldRetry(err, attempt, effectivePolicy)) {
-        return {
-          success: false,
-          error: lastError,
-          attempts: attempt + 1,
-          totalDelayMs
-        };
-      }
-      if (attempt < effectivePolicy.maxRetries) {
-        const delay = calculateDelay(attempt, effectivePolicy);
-        totalDelayMs += delay;
-        await sleep(delay);
-      }
-    }
+  const { withRetry: coreRetry } = await Promise.resolve().then(() => (init_retry(), retry_exports));
+  try {
+    const value = await coreRetry(fn, {
+      maxAttempts: effectivePolicy.maxRetries + 1,
+      baseDelayMs: effectivePolicy.baseDelayMs,
+      maxDelayMs: effectivePolicy.maxDelayMs,
+      retryableErrors: [(err) => shouldRetry(err, 0, effectivePolicy)]
+    });
+    return { success: true, value, attempts: 1, totalDelayMs: 0 };
+  } catch (err) {
+    const error40 = err instanceof Error ? err : new Error(String(err));
+    const context = err;
+    return {
+      success: false,
+      error: error40,
+      attempts: context.attempts ?? effectivePolicy.maxRetries + 1,
+      totalDelayMs: context.totalDelayMs ?? 0
+    };
   }
-  return {
-    success: false,
-    error: lastError ?? new Error("Retry exhausted without error"),
-    attempts: effectivePolicy.maxRetries + 1,
-    totalDelayMs
-  };
 }
 async function recoverCrashedAgents(thresholdMs = 3e4, cwd) {
   const results = [];
@@ -16884,11 +16926,8 @@ async function recoverCrashedAgents(thresholdMs = 3e4, cwd) {
   }
   return results;
 }
-function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
-}
 var DEFAULT_RETRY_POLICY;
-var init_retry = __esm({
+var init_retry2 = __esm({
   "packages/core/src/agents/retry.ts"() {
     "use strict";
     init_registry2();
@@ -16951,7 +16990,7 @@ __export(agents_exports, {
   updateAgentSpecializations: () => updateAgentSpecializations,
   updateAgentStatus: () => updateAgentStatus,
   updateCapacity: () => updateCapacity,
-  withRetry: () => withRetry
+  withRetry: () => withRetry2
 });
 var init_agents = __esm({
   "packages/core/src/agents/index.ts"() {
@@ -16962,7 +17001,7 @@ var init_agents = __esm({
     init_execution_learning();
     init_health_monitor();
     init_registry2();
-    init_retry();
+    init_retry2();
   }
 });
 
@@ -37172,68 +37211,16 @@ var init_issue = __esm({
   }
 });
 
-// packages/core/src/lib/retry.ts
-async function withRetry2(fn, options) {
-  const maxAttempts = options?.maxAttempts ?? 3;
-  const baseDelayMs = options?.baseDelayMs ?? 2e3;
-  const maxDelayMs = options?.maxDelayMs ?? 3e4;
-  const retryableErrors = options?.retryableErrors;
-  let lastError;
-  let totalDelayMs = 0;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      const isLastAttempt = attempt === maxAttempts;
-      if (isLastAttempt) break;
-      if (retryableErrors !== void 0 && !isRetryable(err, retryableErrors)) break;
-      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
-      totalDelayMs += delay;
-      await sleep2(delay);
-    }
-  }
-  const context = { attempts: maxAttempts, totalDelayMs };
-  augmentError(lastError, context);
-  throw lastError;
-}
-function computeDelay(attempt, baseDelayMs, maxDelayMs) {
-  const exponential = baseDelayMs * 2 ** (attempt - 1);
-  return Math.min(exponential, maxDelayMs);
-}
-function isRetryable(err, predicates) {
-  const message = err instanceof Error ? err.message : String(err);
-  return predicates.some((predicate) => {
-    if (predicate instanceof RegExp) return predicate.test(message);
-    return predicate(err);
-  });
-}
-function augmentError(err, context) {
-  if (err instanceof Error) {
-    const mutableErr = err;
-    mutableErr.attempts = context.attempts;
-    mutableErr.totalDelayMs = context.totalDelayMs;
-  }
-}
-function sleep2(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
-}
-var init_retry2 = __esm({
-  "packages/core/src/lib/retry.ts"() {
-    "use strict";
-  }
-});
-
 // packages/core/src/lib/index.ts
 var lib_exports = {};
 __export(lib_exports, {
   computeDelay: () => computeDelay,
-  withRetry: () => withRetry2
+  withRetry: () => withRetry
 });
 var init_lib = __esm({
   "packages/core/src/lib/index.ts"() {
     "use strict";
-    init_retry2();
+    init_retry();
   }
 });
 
@@ -38812,6 +38799,19 @@ var init_config = __esm({
         requireNotes: false,
         multiSession: false
       },
+      enforcement: {
+        acceptance: {
+          mode: "block",
+          requiredForPriorities: ["critical", "high", "medium", "low"],
+          minimumCriteria: 3
+        },
+        session: { requiredForMutate: true }
+      },
+      verification: {
+        enabled: true,
+        maxRounds: 3,
+        requiredGates: ["implemented", "testsPassed", "qaPassed"]
+      },
       lifecycle: {
         mode: "strict"
       },
@@ -41140,17 +41140,17 @@ function checkMin(criteria, min) {
 }
 async function createAcceptanceEnforcement(cwd) {
   const isTest = !!process.env.VITEST;
-  const modeRaw = await getRawConfigValue("enforcement.acceptance.mode", cwd);
-  const prioritiesRaw = await getRawConfigValue(
-    "enforcement.acceptance.requiredForPriorities",
-    cwd
-  );
-  const minCriteriaRaw = await getRawConfigValue("enforcement.acceptance.minimumCriteria", cwd);
-  const defaultPriorityRaw = await getRawConfigValue("defaults.priority", cwd);
-  const mode = modeRaw === "off" || modeRaw === "warn" || modeRaw === "block" ? modeRaw : isTest ? "off" : "block";
-  const requiredForPriorities = Array.isArray(prioritiesRaw) ? prioritiesRaw.filter((p) => typeof p === "string") : ["critical", "high", "medium", "low"];
-  const minCriteria = typeof minCriteriaRaw === "number" && Number.isInteger(minCriteriaRaw) ? minCriteriaRaw : 3;
-  const defaultPriority = typeof defaultPriorityRaw === "string" ? defaultPriorityRaw : "medium";
+  const config2 = await loadConfig(cwd);
+  const acceptance = config2.enforcement?.acceptance;
+  const mode = acceptance?.mode ?? (isTest ? "off" : "block");
+  const requiredForPriorities = acceptance?.requiredForPriorities ?? [
+    "critical",
+    "high",
+    "medium",
+    "low"
+  ];
+  const minCriteria = acceptance?.minimumCriteria ?? 3;
+  const defaultPriority = "medium";
   return {
     checkMinimumCriteria: checkMin,
     validateCreation(options) {
@@ -41880,8 +41880,8 @@ async function addTask(options, cwd, accessor) {
       previewTask.completedAt = previewNow;
     }
     if (taskType !== "epic") {
-      const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
-      if (verificationEnabledRaw === true) {
+      const pCfg = await loadConfig(cwd);
+      if (pCfg.verification?.enabled) {
         previewTask.verification = buildDefaultVerification(previewNow);
       }
     }
@@ -41951,8 +41951,8 @@ async function addTask(options, cwd, accessor) {
     task.completedAt = now2;
   }
   if (taskType !== "epic") {
-    const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
-    if (verificationEnabledRaw === true) {
+    const aCfg = await loadConfig(cwd);
+    if (aCfg.verification?.enabled) {
       task.verification = buildDefaultVerification(now2);
     }
   }
@@ -49085,21 +49085,15 @@ function isVerificationGate(value) {
 }
 async function loadCompletionEnforcement(cwd) {
   const isTest = !!process.env.VITEST;
-  const modeRaw = await getRawConfigValue("enforcement.acceptance.mode", cwd);
-  const prioritiesRaw = await getRawConfigValue(
-    "enforcement.acceptance.requiredForPriorities",
-    cwd
-  );
-  const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
-  const verificationRequiredGatesRaw = await getRawConfigValue("verification.requiredGates", cwd);
-  const verificationMaxRoundsRaw = await getRawConfigValue("verification.maxRounds", cwd);
-  const lifecycleModeRaw = await getRawConfigValue("lifecycle.mode", cwd);
-  const acceptanceMode = modeRaw === "off" || modeRaw === "warn" || modeRaw === "block" ? modeRaw : isTest ? "off" : "block";
-  const acceptanceRequiredForPriorities = Array.isArray(prioritiesRaw) ? prioritiesRaw.filter((p) => typeof p === "string") : isTest ? [] : ["critical", "high", "medium", "low"];
-  const verificationEnabled = verificationEnabledRaw === true ? true : verificationEnabledRaw === false ? false : !isTest;
-  const verificationRequiredGates = Array.isArray(verificationRequiredGatesRaw) ? verificationRequiredGatesRaw.filter((g) => typeof g === "string").filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
-  const verificationMaxRounds = typeof verificationMaxRoundsRaw === "number" && Number.isInteger(verificationMaxRoundsRaw) ? verificationMaxRoundsRaw : 5;
-  const lifecycleMode = lifecycleModeRaw === "strict" || lifecycleModeRaw === "warn" || lifecycleModeRaw === "advisory" || lifecycleModeRaw === "none" || lifecycleModeRaw === "off" ? lifecycleModeRaw : isTest ? "off" : "strict";
+  const config2 = await loadConfig(cwd);
+  const acceptance = config2.enforcement?.acceptance;
+  const verificationCfg = config2.verification;
+  const acceptanceMode = acceptance?.mode ?? (isTest ? "off" : "block");
+  const acceptanceRequiredForPriorities = acceptance?.requiredForPriorities ?? (isTest ? [] : ["critical", "high", "medium", "low"]);
+  const verificationEnabled = verificationCfg?.enabled ?? !isTest;
+  const verificationRequiredGates = (verificationCfg?.requiredGates ?? []).filter(isVerificationGate).length > 0 ? (verificationCfg?.requiredGates ?? []).filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
+  const verificationMaxRounds = verificationCfg?.maxRounds ?? 5;
+  const lifecycleMode = config2.lifecycle?.mode ?? (isTest ? "off" : "strict");
   return {
     acceptanceMode,
     acceptanceRequiredForPriorities,
@@ -67843,6 +67837,7 @@ __export(src_exports, {
   getCleoDirAbsolute: () => getCleoDirAbsolute,
   getCleoErrorRegistry: () => getCleoErrorRegistry,
   getCleoHome: () => getCleoHome,
+  getCleoTemplatesTildePath: () => getCleoTemplatesTildePath,
   getCleoVersion: () => getCleoVersion,
   getConfigPath: () => getConfigPath,
   getConfigValue: () => getConfigValue,
@@ -67974,12 +67969,14 @@ __export(src_exports, {
   tokenUsageMethodSchema: () => tokenUsageMethodSchema,
   tokenUsageTransportSchema: () => tokenUsageTransportSchema,
   ui: () => ui_exports,
+  updateProjectName: () => updateProjectName,
   updateTask: () => updateTask,
   validateAgainstSchema: () => validateAgainstSchema,
   validation: () => validation_exports
 });
 var init_src2 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -78754,6 +78751,7 @@ __export(internal_exports, {
   getCleoDirAbsolute: () => getCleoDirAbsolute,
   getCleoErrorRegistry: () => getCleoErrorRegistry,
   getCleoHome: () => getCleoHome,
+  getCleoTemplatesTildePath: () => getCleoTemplatesTildePath,
   getCleoVersion: () => getCleoVersion,
   getConfigPath: () => getConfigPath,
   getConfigValue: () => getConfigValue,
@@ -79120,6 +79118,7 @@ __export(internal_exports, {
   updateAgentStatus: () => updateAgentStatus,
   updateCapacity: () => updateCapacity,
   updatePatternStats: () => updatePatternStats,
+  updateProjectName: () => updateProjectName,
   updateTask: () => updateTask,
   validateAgainstSchema: () => validateAgainstSchema,
   validateAllAdrs: () => validateAllAdrs,
@@ -79144,8 +79143,8 @@ __export(internal_exports, {
   validateWorkflowGateStatus: () => validateWorkflowGateStatus,
   validateWorkflowGateUpdate: () => validateWorkflowGateUpdate,
   validation: () => validation_exports,
-  withRetry: () => withRetry,
-  withRetryShared: () => withRetry2,
+  withRetry: () => withRetry2,
+  withRetryShared: () => withRetry,
   writeMemoryBridge: () => writeMemoryBridge,
   writeSnapshot: () => writeSnapshot
 });
@@ -79171,7 +79170,7 @@ var init_internal = __esm({
     init_prediction();
     init_create();
     init_diagnostics();
-    init_retry2();
+    init_retry();
     init_chain_store();
     init_lifecycle2();
     init_tessera_engine();
@@ -90711,16 +90710,18 @@ var PipelineHandler = class {
           return wrapResult(result, "query", "pipeline", "phase.list", startTime);
         }
         const listData = result.data;
+        const phases = listData.phases ?? [];
+        const total = listData.summary?.total ?? phases.length;
         const { limit, offset } = getListParams(params);
-        const page = paginate(listData.phases, limit, offset);
+        const page = paginate(phases, limit, offset);
         return {
           _meta: dispatchMeta("query", "pipeline", "phase.list", startTime),
           success: true,
           data: {
             ...listData,
             phases: page.items,
-            total: listData.summary.total,
-            filtered: listData.summary.total
+            total,
+            filtered: total
           },
           page: page.page
         };
@@ -94603,6 +94604,40 @@ function findProjectRoot() {
 function registerDetectDriftCommand(program) {
   program.command("detect-drift").description("Detect documentation drift against TypeScript source of truth").action(async () => {
     const projectRoot = findProjectRoot();
+    const isCleoRepo = existsSync121(join114(projectRoot, "src", "cli", "commands")) || existsSync121(join114(projectRoot, "packages", "cleo", "src"));
+    if (!isCleoRepo) {
+      const userResult = {
+        summary: { totalChecks: 1, passed: 0, warnings: 0, errors: 0, exitCode: 0 },
+        checks: [],
+        recommendations: []
+      };
+      const injPath = join114(projectRoot, ".cleo", "templates", "CLEO-INJECTION.md");
+      if (existsSync121(injPath)) {
+        const content = safeRead(injPath);
+        userResult.checks.push({
+          name: "Agent injection",
+          status: content.length > 100 ? "pass" : "warn",
+          message: content.length > 100 ? "Agent injection template exists" : "Template appears incomplete",
+          issues: []
+        });
+        userResult.summary.passed = content.length > 100 ? 1 : 0;
+        userResult.summary.warnings = content.length > 100 ? 0 : 1;
+      } else {
+        userResult.checks.push({
+          name: "Agent injection",
+          status: "warn",
+          message: "No injection template found \u2014 run `cleo init` to create one",
+          issues: []
+        });
+        userResult.summary.warnings = 1;
+      }
+      userResult.summary.exitCode = userResult.summary.errors > 0 ? 2 : userResult.summary.warnings > 0 ? 1 : 0;
+      userResult.recommendations.push(
+        "detect-drift source checks only apply to the CLEO monorepo. Run from the cleo source tree for full analysis."
+      );
+      cliOutput(userResult, { command: "detect-drift" });
+      process.exit(userResult.summary.exitCode);
+    }
     const result = {
       summary: {
         totalChecks: 0,