@cleocode/cleo 2026.4.72 → 2026.4.74

package/dist/cli/index.js

@@ -91183,7 +91183,6 @@ __export(src_exports, {
 });
 var init_src3 = __esm({
   "packages/core/src/index.ts"() {
-    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -92550,12 +92549,8 @@ function createAttachmentStore() {
           await db.update(attachments).set({ refCount: sql14`ref_count + 1` }).where(eq14(attachments.id, attachmentId)).run();
           nativeDb.prepare("COMMIT").run();
           if (wasNew) {
-            try {
-              await mkdir18(join112(filePath, ".."), { recursive: true });
-              await writeFile13(filePath, buf);
-            } catch (err2) {
-              throw err2;
-            }
+            await mkdir18(join112(filePath, ".."), { recursive: true });
+            await writeFile13(filePath, buf);
           }
           const finalRow = await db.select().from(attachments).where(eq14(attachments.id, attachmentId)).get();
           return rowToMetadata(finalRow);
@@ -107358,7 +107353,7 @@ ${stderr2}`.trim(), MAX_EVIDENCE_BYTES);
       `${gate.tool} exited with ${exitCode}`
     );
   }
-  if (toolDef.errorPattern && toolDef.errorPattern.test(combined)) {
+  if (toolDef.errorPattern?.test(combined)) {
     return makeResult(
       index2,
       gate,
@@ -141639,8 +141634,7 @@ function toHistoryEntry(e) {
 }
 async function taskCompleteStrict(projectRoot, taskId, notes, force) {
   try {
-    const { loadConfig: loadConfig4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-    const config2 = await loadConfig4(projectRoot);
+    const config2 = await loadConfig(projectRoot);
     const lifecycleMode = config2.lifecycle?.mode ?? "strict";
     if (lifecycleMode === "strict") {
       const ivtrState = await getIvtrState(taskId, { cwd: projectRoot });
@@ -141727,6 +141721,81 @@ async function taskCompleteStrict(projectRoot, taskId, notes, force) {
         };
       }
     }
+    if (lifecycleMode === "strict" || lifecycleMode === "advisory") {
+      const accessor = await getAccessor(projectRoot);
+      const task = await accessor.loadSingleTask(taskId);
+      if (task?.parentId) {
+        const parent = await accessor.loadSingleTask(task.parentId);
+        if (parent?.type === "epic") {
+          const earlyStages = /* @__PURE__ */ new Set([
+            "research",
+            "consensus",
+            "architecture_decision",
+            "specification",
+            "decomposition"
+          ]);
+          const epicStage = parent.pipelineStage ?? null;
+          if (epicStage && earlyStages.has(epicStage)) {
+            const msg = `Task ${taskId} cannot complete: parent epic ${task.parentId} is still in '${epicStage}' stage. Advance the epic past decomposition before completing children.`;
+            if (lifecycleMode === "strict" && !force) {
+              return engineError("E_LIFECYCLE_GATE_FAILED", msg, {
+                details: {
+                  taskId,
+                  parentEpicId: task.parentId,
+                  epicStage,
+                  requiredStages: ["implementation", "validation", "testing", "release"]
+                },
+                fix: `Advance the parent epic via 'cleo lifecycle complete ${task.parentId} ${epicStage}' and then the next stages, or use '--force' to bypass.`
+              });
+            }
+            getLogger("engine:lifecycle").warn(
+              {
+                taskId,
+                parentEpicId: task.parentId,
+                epicStage,
+                mode: lifecycleMode,
+                forced: force === true
+              },
+              lifecycleMode === "advisory" ? `[ADVISORY] parent-epic lifecycle gate: ${msg}` : `[OWNER WARNING] cleo complete --force bypassed parent-epic lifecycle gate: ${msg}`
+            );
+            if (lifecycleMode === "strict" && force === true) {
+              try {
+                const now2 = (/* @__PURE__ */ new Date()).toISOString();
+                if (!task.verification) {
+                  task.verification = {
+                    round: 0,
+                    gates: {},
+                    passed: false,
+                    lastAgent: null,
+                    lastUpdated: null,
+                    failureLog: []
+                  };
+                }
+                if (!task.verification.failureLog) {
+                  task.verification.failureLog = [];
+                }
+                task.verification.failureLog.push({
+                  round: task.verification.round,
+                  agent: "owner-forced",
+                  reason: `OWNER FORCED cleo complete --force \u2014 parent-epic lifecycle gate bypass. Epic ${task.parentId} at stage='${epicStage}'.`,
+                  timestamp: now2
+                });
+                task.updatedAt = now2;
+                await accessor.upsertSingleTask(task);
+              } catch {
+              }
+              const innerResult = await taskComplete(projectRoot, taskId, notes);
+              if (!innerResult.success)
+                return innerResult;
+              return {
+                success: true,
+                data: { ...innerResult.data, lifecycleGateBypassed: true }
+              };
+            }
+          }
+        }
+      }
+    }
     return taskComplete(projectRoot, taskId, notes);
   } catch (err2) {
     return cleoErrorToEngineError(err2, "E_INTERNAL", "Failed to complete task (strict mode)");