@cleocode/cleo 2026.4.80 → 2026.4.83

package/dist/cli/index.js

@@ -1760,11 +1760,17 @@ function rowToTask(row) {
   };
 }
 function taskToRow(task) {
+  const status = task.status ?? "pending";
+  let pipelineStage = task.pipelineStage ?? null;
+  if (pipelineStage === null || pipelineStage === void 0) {
+    if (status === "done") pipelineStage = "contribution";
+    else if (status === "cancelled") pipelineStage = "cancelled";
+  }
   return {
     id: task.id,
     title: task.title ?? "",
     description: task.description ?? null,
-    status: task.status ?? "pending",
+    status,
     priority: task.priority ?? "medium",
     type: task.type ?? null,
     parentId: task.parentId ?? null,
@@ -1789,7 +1795,7 @@ function taskToRow(task) {
     createdBy: task.provenance?.createdBy ?? null,
     modifiedBy: task.provenance?.modifiedBy ?? null,
     sessionId: task.provenance?.sessionId ?? null,
-    pipelineStage: task.pipelineStage ?? null,
+    pipelineStage,
     assignee: task.assignee ?? null
   };
 }
@@ -17403,9 +17409,9 @@ async function readSequenceFromDb(cwd, accessor) {
     return isValidSequenceState(value) ? value : null;
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
-  const rows = await db.select().from(schemaMeta).where(eq21(schemaMeta.key, SEQUENCE_META_KEY)).all();
+  const rows = await db.select().from(schemaMeta).where(eq20(schemaMeta.key, SEQUENCE_META_KEY)).all();
   const raw = rows[0]?.value;
   if (!raw) return null;
   try {
@@ -19236,7 +19242,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     return result;
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { and: and16, eq: eq21 } = await import("drizzle-orm");
+  const { and: and16, eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   for (const filePath of matchingFiles) {
@@ -19246,7 +19252,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
       const fm = record2.frontmatter;
       const content = readFileSync5(filePath, "utf-8");
       const relativePath = `.cleo/adrs/${filename}`;
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq21(architectureDecisions.id, record2.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq20(architectureDecisions.id, record2.id)).all();
       const rowBase = {
         id: record2.id,
         title: record2.title,
@@ -19266,19 +19272,19 @@ async function linkPipelineAdr(projectRoot, taskId) {
         updatedAt: now2
       };
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq21(architectureDecisions.id, record2.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq20(architectureDecisions.id, record2.id));
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now2 });
       }
       result.synced++;
-      await db.delete(adrTaskLinks).where(and16(eq21(adrTaskLinks.adrId, record2.id), eq21(adrTaskLinks.taskId, taskId)));
+      await db.delete(adrTaskLinks).where(and16(eq20(adrTaskLinks.adrId, record2.id), eq20(adrTaskLinks.taskId, taskId)));
       await db.insert(adrTaskLinks).values({ adrId: record2.id, taskId, linkType: "implements" });
       result.linked.push({ adrId: record2.id, taskId });
       if (fm["Related ADRs"]) {
         const relatedIds = fm["Related ADRs"].split(",").map((r) => r.trim()).filter((r) => /^ADR-\d+$/.test(r));
         for (const toId of relatedIds) {
           try {
-            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq21(architectureDecisions.id, toId)).all();
+            const targetExists = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq20(architectureDecisions.id, toId)).all();
             if (targetExists.length > 0) {
               await db.insert(adrRelations).values({ fromAdrId: record2.id, toAdrId: toId, relationType: "related" }).onConflictDoNothing();
             }
@@ -19442,7 +19448,7 @@ async function syncAdrsToDb(projectRoot) {
     return result;
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const allFiles = collectAdrFiles(adrsDir);
@@ -19459,7 +19465,7 @@ async function syncAdrsToDb(projectRoot) {
       let supersededById = fm["Superseded By"] ? extractAdrIdFromRef(fm["Superseded By"]) : null;
       let amendsId = fm.Amends ? extractAdrIdFromRef(fm.Amends) : null;
       if (supersedesId) {
-        const exists2 = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq21(architectureDecisions.id, supersedesId)).all();
+        const exists2 = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq20(architectureDecisions.id, supersedesId)).all();
         if (exists2.length === 0) {
           result.warnings.push(
             `${record2.id}: supersedes target ${supersedesId} not found in DB, setting to null`
@@ -19468,7 +19474,7 @@ async function syncAdrsToDb(projectRoot) {
         }
       }
       if (supersededById) {
-        const exists2 = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq21(architectureDecisions.id, supersededById)).all();
+        const exists2 = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq20(architectureDecisions.id, supersededById)).all();
         if (exists2.length === 0) {
           result.warnings.push(
             `${record2.id}: supersededBy target ${supersededById} not found in DB, setting to null`
@@ -19477,7 +19483,7 @@ async function syncAdrsToDb(projectRoot) {
         }
       }
       if (amendsId) {
-        const exists2 = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq21(architectureDecisions.id, amendsId)).all();
+        const exists2 = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq20(architectureDecisions.id, amendsId)).all();
         if (exists2.length === 0) {
           result.warnings.push(
             `${record2.id}: amends target ${amendsId} not found in DB, setting to null`
@@ -19503,18 +19509,18 @@ async function syncAdrsToDb(projectRoot) {
         topics: fm.Topics ?? null,
         updatedAt: now2
       };
-      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq21(architectureDecisions.id, record2.id)).all();
+      const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq20(architectureDecisions.id, record2.id)).all();
       if (existing.length > 0) {
-        await db.update(architectureDecisions).set(rowBase).where(eq21(architectureDecisions.id, record2.id));
+        await db.update(architectureDecisions).set(rowBase).where(eq20(architectureDecisions.id, record2.id));
         result.updated++;
       } else {
         await db.insert(architectureDecisions).values({ ...rowBase, createdAt: now2 });
         result.inserted++;
       }
-      await db.delete(adrTaskLinks).where(eq21(adrTaskLinks.adrId, record2.id));
+      await db.delete(adrTaskLinks).where(eq20(adrTaskLinks.adrId, record2.id));
       if (fm["Related Tasks"]) {
         for (const taskId of parseTaskIds2(fm["Related Tasks"])) {
-          const taskExists2 = await db.select({ id: tasks.id }).from(tasks).where(eq21(tasks.id, taskId)).all();
+          const taskExists2 = await db.select({ id: tasks.id }).from(tasks).where(eq20(tasks.id, taskId)).all();
           if (taskExists2.length === 0) {
             result.warnings.push(
               `${record2.id}: related task ${taskId} not found in DB, skipping link`
@@ -25196,16 +25202,16 @@ async function queryAudit(options) {
   try {
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and16, eq: eq21, gte: gte4, or: or7 } = await import("drizzle-orm");
+    const { and: and16, eq: eq20, gte: gte4, or: or7 } = await import("drizzle-orm");
     const db = await getDb4(process.cwd());
     const conditions = [];
-    if (options?.sessionId) conditions.push(eq21(auditLog2.sessionId, options.sessionId));
-    if (options?.domain) conditions.push(eq21(auditLog2.domain, options.domain));
+    if (options?.sessionId) conditions.push(eq20(auditLog2.sessionId, options.sessionId));
+    if (options?.domain) conditions.push(eq20(auditLog2.domain, options.domain));
     if (options?.operation)
       conditions.push(
-        or7(eq21(auditLog2.operation, options.operation), eq21(auditLog2.action, options.operation))
+        or7(eq20(auditLog2.operation, options.operation), eq20(auditLog2.action, options.operation))
       );
-    if (options?.taskId) conditions.push(eq21(auditLog2.taskId, options.taskId));
+    if (options?.taskId) conditions.push(eq20(auditLog2.taskId, options.taskId));
     if (options?.since) conditions.push(gte4(auditLog2.timestamp, options.since));
     const limit = options?.limit ?? 1e3;
     const rows = await db.select().from(auditLog2).where(conditions.length > 0 ? and16(...conditions) : void 0).orderBy(auditLog2.timestamp).limit(limit);
@@ -48510,7 +48516,7 @@ async function backfillRewardSignals(projectRoot, sessionId, lookbackDays = 30)
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const tasksDb = await getDb4(projectRoot);
     const { tasks: tasks2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
-    const { and: and16, eq: eq21, inArray: inArray9, gte: gte4, or: or7, isNotNull: isNotNull3 } = await import("drizzle-orm");
+    const { and: and16, eq: eq20, inArray: inArray8, gte: gte4, or: or7, isNotNull: isNotNull3 } = await import("drizzle-orm");
     const cutoffTs = new Date(Date.now() - lookbackDays * 24 * 60 * 60 * 1e3).toISOString().replace("T", " ").slice(0, 19);
     const rawRows = await tasksDb.select({
       id: tasks2.id,
@@ -48520,8 +48526,8 @@ async function backfillRewardSignals(projectRoot, sessionId, lookbackDays = 30)
       cancelledAt: tasks2.cancelledAt
     }).from(tasks2).where(
       and16(
-        eq21(tasks2.sessionId, sessionId),
-        inArray9(tasks2.status, ["done", "cancelled"]),
+        eq20(tasks2.sessionId, sessionId),
+        inArray8(tasks2.status, ["done", "cancelled"]),
         or7(
           and16(isNotNull3(tasks2.completedAt), gte4(tasks2.completedAt, cutoffTs)),
           and16(isNotNull3(tasks2.cancelledAt), gte4(tasks2.cancelledAt, cutoffTs))
@@ -60037,13 +60043,13 @@ function extractYamlArray(content, field) {
   }
   const lines = content.split("\n");
   const items = [];
-  let inArray9 = false;
+  let inArray8 = false;
   for (const line2 of lines) {
     if (line2.match(new RegExp(`^${field}:`))) {
-      inArray9 = true;
+      inArray8 = true;
       continue;
     }
-    if (inArray9) {
+    if (inArray8) {
       const itemMatch = line2.match(/^\s+-\s+["']?(.+?)["']?\s*$/);
       if (itemMatch) {
         items.push(itemMatch[1].trim());
@@ -62162,12 +62168,12 @@ async function getEnforcementMode(cwd) {
 }
 async function getLifecycleStatus(epicId, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineResult = await db.select({
     pipeline: lifecyclePipelines,
     task: tasks
-  }).from(lifecyclePipelines).innerJoin(tasks, eq21(lifecyclePipelines.taskId, tasks.id)).where(eq21(lifecyclePipelines.taskId, epicId)).limit(1);
+  }).from(lifecyclePipelines).innerJoin(tasks, eq20(lifecyclePipelines.taskId, tasks.id)).where(eq20(lifecyclePipelines.taskId, epicId)).limit(1);
   if (pipelineResult.length === 0) {
     return {
       epicId,
@@ -62180,7 +62186,7 @@ async function getLifecycleStatus(epicId, cwd) {
   }
   const task = pipelineResult[0].task;
   const pipelineId = `pipeline-${epicId}`;
-  const stageRows = await db.select().from(lifecycleStages).where(eq21(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
+  const stageRows = await db.select().from(lifecycleStages).where(eq20(lifecycleStages.pipelineId, pipelineId)).orderBy(lifecycleStages.sequence);
   const stageDataMap = /* @__PURE__ */ new Map();
   for (const row of stageRows) {
     let parsedChain;
@@ -62249,10 +62255,10 @@ async function getLifecycleStatus(epicId, cwd) {
 }
 async function getLifecycleHistory(epicId, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq21(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq20(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return { epicId, history: [] };
   }
@@ -62282,7 +62288,7 @@ async function getLifecycleHistory(epicId, cwd) {
   }
   const stageIds = stages.map((s3) => s3.id);
   if (stageIds.length > 0) {
-    const gateResults = await db.select().from(lifecycleGateResults).where(eq21(lifecycleGateResults.stageId, stageIds[0]));
+    const gateResults = await db.select().from(lifecycleGateResults).where(eq20(lifecycleGateResults.stageId, stageIds[0]));
     for (const gate of gateResults) {
       const stageName = stageIdToName.get(gate.stageId);
       if (stageName) {
@@ -62295,7 +62301,7 @@ async function getLifecycleHistory(epicId, cwd) {
       }
     }
     for (let i = 1; i < stageIds.length; i++) {
-      const additionalGates = await db.select().from(lifecycleGateResults).where(eq21(lifecycleGateResults.stageId, stageIds[i]));
+      const additionalGates = await db.select().from(lifecycleGateResults).where(eq20(lifecycleGateResults.stageId, stageIds[i]));
       for (const gate of additionalGates) {
         const stageName = stageIdToName.get(gate.stageId);
         if (stageName) {
@@ -62314,16 +62320,16 @@ async function getLifecycleHistory(epicId, cwd) {
 }
 async function getLifecycleGates(epicId, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineId = `pipeline-${epicId}`;
-  const stages = await db.select().from(lifecycleStages).where(eq21(lifecycleStages.pipelineId, pipelineId));
+  const stages = await db.select().from(lifecycleStages).where(eq20(lifecycleStages.pipelineId, pipelineId));
   if (stages.length === 0) {
     return {};
   }
   const gates = {};
   for (const stage of stages) {
-    const gateRows = await db.select().from(lifecycleGateResults).where(eq21(lifecycleGateResults.stageId, stage.id));
+    const gateRows = await db.select().from(lifecycleGateResults).where(eq20(lifecycleGateResults.stageId, stage.id));
     if (gateRows.length > 0) {
       gates[stage.stageName] = {};
       for (const gateRow of gateRows) {
@@ -62387,7 +62393,7 @@ async function checkStagePrerequisites(epicId, targetStage, cwd) {
 }
 async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
   const pipelineId = `pipeline-${epicId}`;
   const stageId = `stage-${epicId}-${stageName}`;
@@ -62395,7 +62401,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
   getNativeDb3().prepare(
     `INSERT OR IGNORE INTO tasks (id, title, status, priority, created_at) VALUES (?, ?, 'pending', 'medium', datetime('now'))`
   ).run(epicId, `Task ${epicId}`);
-  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq21(lifecyclePipelines.id, pipelineId)).limit(1).all();
+  const existingPipeline = await db.select().from(lifecyclePipelines).where(eq20(lifecyclePipelines.id, pipelineId)).limit(1).all();
   if (existingPipeline.length === 0) {
     await db.insert(lifecyclePipelines).values({
       id: pipelineId,
@@ -62405,7 +62411,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
       startedAt: options.now
     }).run();
   }
-  const existingStage = await db.select().from(lifecycleStages).where(eq21(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq20(lifecycleStages.id, stageId)).limit(1).all();
   if (existingStage.length === 0) {
     const sequence = isValidStage(stageName) ? STAGE_ORDER[stageName] : 0;
     await db.insert(lifecycleStages).values({
@@ -62418,7 +62424,7 @@ async function ensureLifecycleContext(epicId, stageName, cwd, options) {
     }).run();
   }
   if (options.updateCurrentStage) {
-    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq21(lifecyclePipelines.id, pipelineId)).run();
+    await db.update(lifecyclePipelines).set({ currentStageId: stageId }).where(eq20(lifecyclePipelines.id, pipelineId)).run();
   }
   return { db, pipelineId, stageId };
 }
@@ -62433,7 +62439,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       `Invalid status: ${status}. Valid: ${validStatuses.join(", ")}`
     );
   }
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = stage;
   const { db, stageId, pipelineId } = await ensureLifecycleContext(epicId, stage, cwd, {
@@ -62449,7 +62455,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
     status,
     related: artifact.related
   };
-  const existingStage = await db.select().from(lifecycleStages).where(eq21(lifecycleStages.id, stageId)).limit(1).all();
+  const existingStage = await db.select().from(lifecycleStages).where(eq20(lifecycleStages.id, stageId)).limit(1).all();
   const sequence = STAGE_ORDER[stage];
   const stageValues = {
     status,
@@ -62476,7 +62482,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
       provenanceChainJson: JSON.stringify(provenanceChain)
     }).run();
   } else {
-    await db.update(lifecycleStages).set(stageValues).where(eq21(lifecycleStages.id, stageId)).run();
+    await db.update(lifecycleStages).set(stageValues).where(eq20(lifecycleStages.id, stageId)).run();
   }
   if (status === "completed") {
     await linkProvenance(epicId, stageName, artifact.absolutePath, cwd);
@@ -62487,7 +62493,7 @@ async function recordStageProgress(epicId, stage, status, notes, cwd) {
     }
   }
   if (status === "in_progress" || status === "completed") {
-    await db.update(tasks).set({ pipelineStage: stage }).where(eq21(tasks.id, epicId)).run();
+    await db.update(tasks).set({ pipelineStage: stage }).where(eq20(tasks.id, epicId)).run();
   }
   return { epicId, stage, status, timestamp: now2 };
 }
@@ -62499,7 +62505,7 @@ async function resetStage(epicId, stage, reason, cwd) {
   if (!PIPELINE_STAGES.includes(stage)) {
     throw new CleoError(2 /* INVALID_INPUT */, `Invalid stage: ${stage}`);
   }
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const { db, stageId } = await ensureLifecycleContext(epicId, stage, cwd, {
     now: now2,
@@ -62512,11 +62518,11 @@ async function resetStage(epicId, stage, reason, cwd) {
     skippedAt: null,
     skipReason: null,
     notesJson: JSON.stringify([`Reset: ${reason}`])
-  }).where(eq21(lifecycleStages.id, stageId)).run();
+  }).where(eq20(lifecycleStages.id, stageId)).run();
   return { epicId, stage, reason };
 }
 async function passGate(epicId, gateName, agent, notes, cwd) {
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -62525,7 +62531,7 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq21(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq20(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -62537,14 +62543,14 @@ async function passGate(epicId, gateName, agent, notes, cwd) {
     reason: null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq21(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq20(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
   return { epicId, gateName, timestamp: now2 };
 }
 async function failGate(epicId, gateName, reason, cwd) {
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const stageName = gateName.split("-")[0];
   const gateId = `gate-${epicId}-${stageName}-${gateName}`;
@@ -62553,7 +62559,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     stageStatusOnCreate: "in_progress",
     updateCurrentStage: true
   });
-  const existingGate = await db.select().from(lifecycleGateResults).where(eq21(lifecycleGateResults.id, gateId)).limit(1).all();
+  const existingGate = await db.select().from(lifecycleGateResults).where(eq20(lifecycleGateResults.id, gateId)).limit(1).all();
   const gateValues = {
     id: gateId,
     stageId,
@@ -62565,7 +62571,7 @@ async function failGate(epicId, gateName, reason, cwd) {
     reason: reason ?? null
   };
   if (existingGate.length > 0) {
-    await db.update(lifecycleGateResults).set(gateValues).where(eq21(lifecycleGateResults.id, gateId)).run();
+    await db.update(lifecycleGateResults).set(gateValues).where(eq20(lifecycleGateResults.id, gateId)).run();
   } else {
     await db.insert(lifecycleGateResults).values(gateValues).run();
   }
@@ -62771,6 +62777,9 @@ var init_enforcement = __esm({
 });
 
 // packages/core/src/tasks/pipeline-stage.ts
+function isTerminalPipelineStage(stage) {
+  return !!stage && TERMINAL_PIPELINE_STAGES.has(stage);
+}
 function isValidPipelineStage(stage) {
   return TASK_PIPELINE_STAGES.includes(stage);
 }
@@ -62822,7 +62831,7 @@ function validatePipelineTransition(currentStage, newStage) {
     );
   }
 }
-var TASK_PIPELINE_STAGES, STAGE_ORDER2;
+var TASK_PIPELINE_STAGES, STAGE_ORDER2, TERMINAL_PIPELINE_STAGES;
 var init_pipeline_stage = __esm({
   "packages/core/src/tasks/pipeline-stage.ts"() {
     "use strict";
@@ -62838,7 +62847,8 @@ var init_pipeline_stage = __esm({
       "validation",
       "testing",
       "release",
-      "contribution"
+      "contribution",
+      "cancelled"
     ];
     STAGE_ORDER2 = {
       research: 1,
@@ -62850,8 +62860,13 @@ var init_pipeline_stage = __esm({
       validation: 7,
       testing: 8,
       release: 9,
-      contribution: 10
+      contribution: 10,
+      cancelled: 11
     };
+    TERMINAL_PIPELINE_STAGES = /* @__PURE__ */ new Set([
+      "contribution",
+      "cancelled"
+    ]);
   }
 });
 
@@ -67450,9 +67465,9 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
   const projectHash = generateProjectHash(projectPath);
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  const existingRows = await db.select().from(projectRegistry).where(eq21(projectRegistry.projectHash, projectHash));
+  const existingRows = await db.select().from(projectRegistry).where(eq20(projectRegistry.projectHash, projectHash));
   const existing = existingRows[0];
   if (existing?.permissions) {
     throw new CleoError(
@@ -67461,7 +67476,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
     );
   }
   if (!existing) {
-    const nameConflictRows = await db.select().from(projectRegistry).where(eq21(projectRegistry.name, projectName));
+    const nameConflictRows = await db.select().from(projectRegistry).where(eq20(projectRegistry.name, projectName));
     if (nameConflictRows.length > 0) {
       throw new CleoError(
         6 /* VALIDATION_ERROR */,
@@ -67484,7 +67499,7 @@ async function nexusRegister(projectPath, name2, permissions = "read") {
       lastSeen: now2,
       brainDbPath,
       tasksDbPath
-    }).where(eq21(projectRegistry.projectHash, projectHash));
+    }).where(eq20(projectRegistry.projectHash, projectHash));
   } else {
     if (!projectId) {
       projectId = randomUUID4();
@@ -67525,9 +67540,9 @@ async function nexusUnregister(nameOrHash) {
     throw new CleoError(4 /* NOT_FOUND */, `Project not found in registry: ${nameOrHash}`);
   }
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.delete(projectRegistry).where(eq21(projectRegistry.projectHash, project.hash));
+  await db.delete(projectRegistry).where(eq20(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "unregister",
     projectHash: project.hash,
@@ -67549,9 +67564,9 @@ async function nexusList() {
 async function nexusGetProject(nameOrHash) {
   try {
     const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-    const { eq: eq21, or: or7 } = await import("drizzle-orm");
+    const { eq: eq20, or: or7 } = await import("drizzle-orm");
     const db = await getNexusDb2();
-    const rows = await db.select().from(projectRegistry).where(or7(eq21(projectRegistry.projectHash, nameOrHash), eq21(projectRegistry.name, nameOrHash)));
+    const rows = await db.select().from(projectRegistry).where(or7(eq20(projectRegistry.projectHash, nameOrHash), eq20(projectRegistry.name, nameOrHash)));
     const row = rows[0];
     if (!row) return null;
     return rowToProject(row);
@@ -67574,14 +67589,14 @@ async function nexusSync(nameOrHash) {
   const meta3 = await readProjectMeta(project.path);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   await db.update(projectRegistry).set({
     taskCount: meta3.taskCount,
     labelsJson: JSON.stringify(meta3.labels),
     lastSync: now2,
     lastSeen: now2
-  }).where(eq21(projectRegistry.projectHash, project.hash));
+  }).where(eq20(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "sync",
     projectHash: project.hash,
@@ -67595,7 +67610,7 @@ async function nexusSyncAll() {
   let synced = 0;
   let failed = 0;
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   for (const project of projects) {
     try {
@@ -67606,7 +67621,7 @@ async function nexusSyncAll() {
         labelsJson: JSON.stringify(meta3.labels),
         lastSync: now2,
         lastSeen: now2
-      }).where(eq21(projectRegistry.projectHash, project.hash));
+      }).where(eq20(projectRegistry.projectHash, project.hash));
       synced++;
     } catch {
       failed++;
@@ -67626,9 +67641,9 @@ async function nexusUpdateIndexStats(projectPath, stats2) {
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   try {
     const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-    const { eq: eq21 } = await import("drizzle-orm");
+    const { eq: eq20 } = await import("drizzle-orm");
     const db = await getNexusDb2();
-    const rows = await db.select().from(projectRegistry).where(eq21(projectRegistry.projectHash, projectHash));
+    const rows = await db.select().from(projectRegistry).where(eq20(projectRegistry.projectHash, projectHash));
     if (rows.length === 0) {
       try {
         await nexusRegister(projectPath);
@@ -67639,7 +67654,7 @@ async function nexusUpdateIndexStats(projectPath, stats2) {
       lastIndexed: now2,
       statsJson: JSON.stringify(stats2),
       lastSeen: now2
-    }).where(eq21(projectRegistry.projectHash, projectHash));
+    }).where(eq20(projectRegistry.projectHash, projectHash));
     await writeNexusAudit({
       action: "update-index-stats",
       projectHash,
@@ -67661,9 +67676,9 @@ async function nexusSetPermission(nameOrHash, permission) {
     throw new CleoError(4 /* NOT_FOUND */, `Project not found in registry: ${nameOrHash}`);
   }
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getNexusDb2();
-  await db.update(projectRegistry).set({ permissions: permission }).where(eq21(projectRegistry.projectHash, project.hash));
+  await db.update(projectRegistry).set({ permissions: permission }).where(eq20(projectRegistry.projectHash, project.hash));
   await writeNexusAudit({
     action: "set-permission",
     projectHash: project.hash,
@@ -67679,12 +67694,12 @@ async function nexusReconcile(projectRoot) {
   }
   await nexusInit();
   const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getNexusDb2();
   const projectId = await readProjectId(projectRoot);
   const currentHash = generateProjectHash(projectRoot);
   if (projectId) {
-    const hashRows2 = await db.select().from(projectRegistry).where(eq21(projectRegistry.projectHash, currentHash));
+    const hashRows2 = await db.select().from(projectRegistry).where(eq20(projectRegistry.projectHash, currentHash));
     const hashMatch2 = hashRows2[0];
     if (hashMatch2 && hashMatch2.projectId !== projectId) {
       await writeNexusAudit({
@@ -67703,12 +67718,12 @@ async function nexusReconcile(projectRoot) {
     }
   }
   if (projectId) {
-    const idRows = await db.select().from(projectRegistry).where(eq21(projectRegistry.projectId, projectId));
+    const idRows = await db.select().from(projectRegistry).where(eq20(projectRegistry.projectId, projectId));
     const existing = idRows[0];
     if (existing) {
       const now2 = (/* @__PURE__ */ new Date()).toISOString();
       if (existing.projectPath === projectRoot) {
-        await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq21(projectRegistry.projectId, projectId));
+        await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq20(projectRegistry.projectId, projectId));
         await writeNexusAudit({
           action: "reconcile",
           projectHash: currentHash,
@@ -67724,7 +67739,7 @@ async function nexusReconcile(projectRoot) {
         projectPath: projectRoot,
         projectHash: currentHash,
         lastSeen: now2
-      }).where(eq21(projectRegistry.projectId, projectId));
+      }).where(eq20(projectRegistry.projectId, projectId));
       await writeNexusAudit({
         action: "reconcile",
         projectHash: currentHash,
@@ -67736,11 +67751,11 @@ async function nexusReconcile(projectRoot) {
       return { status: "path_updated", oldPath, newPath: projectRoot };
     }
   }
-  const hashRows = await db.select().from(projectRegistry).where(eq21(projectRegistry.projectHash, currentHash));
+  const hashRows = await db.select().from(projectRegistry).where(eq20(projectRegistry.projectHash, currentHash));
   const hashMatch = hashRows[0];
   if (hashMatch) {
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq21(projectRegistry.projectHash, currentHash));
+    await db.update(projectRegistry).set({ lastSeen: now2 }).where(eq20(projectRegistry.projectHash, currentHash));
     await writeNexusAudit({
       action: "reconcile",
       projectHash: currentHash,
@@ -69369,6 +69384,9 @@ async function completeTask(options, cwd, accessor) {
   if (completionStage && isValidPipelineStage(completionStage) && EXECUTION_STAGES_FOR_RELEASE.has(completionStage)) {
     task.pipelineStage = "release";
   }
+  if (!isTerminalPipelineStage(task.pipelineStage)) {
+    task.pipelineStage = "contribution";
+  }
   task.status = "done";
   task.completedAt = now2;
   task.updatedAt = now2;
@@ -69392,6 +69410,9 @@ async function completeTask(options, cwd, accessor) {
         parent.status = "done";
         parent.completedAt = now2;
         parent.updatedAt = now2;
+        if (!isTerminalPipelineStage(parent.pipelineStage)) {
+          parent.pipelineStage = "contribution";
+        }
         autoCompleted.push(parent.id);
         autoCompletedTasks.push(parent);
       }
@@ -91406,7 +91427,6 @@ var init_cleo = __esm({
 // packages/core/src/index.ts
 var init_src3 = __esm({
   "packages/core/src/index.ts"() {
-    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -106950,113 +106970,6 @@ var init_types4 = __esm({
   }
 });
 
-// packages/core/src/lifecycle/backfill-pipeline-stage.ts
-import { eq as eq15, inArray as inArray6 } from "drizzle-orm";
-async function backfillPipelineStageFromLifecycle(options = {}, cwd) {
-  const { dryRun = false, force = false } = options;
-  const db = await getDb(cwd);
-  if (!force) {
-    const guard = await db.select().from(schemaMeta).where(eq15(schemaMeta.key, BACKFILL_KEY)).limit(1).all();
-    if (guard.length > 0) {
-      return {
-        alreadyRun: true,
-        dryRun,
-        tasksScanned: 0,
-        tasksUpdated: 0,
-        changes: []
-      };
-    }
-  }
-  const advancingStatuses = [
-    "completed",
-    "in_progress",
-    "skipped"
-  ];
-  const rows = await db.select({
-    taskId: lifecyclePipelines.taskId,
-    stageName: lifecycleStages.stageName,
-    sequence: lifecycleStages.sequence,
-    status: lifecycleStages.status,
-    currentPipelineStage: tasks.pipelineStage
-  }).from(lifecyclePipelines).innerJoin(
-    lifecycleStages,
-    eq15(lifecycleStages.pipelineId, lifecyclePipelines.id)
-  ).innerJoin(tasks, eq15(tasks.id, lifecyclePipelines.taskId)).where(inArray6(lifecycleStages.status, advancingStatuses)).all();
-  const highestPerTask = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const existing = highestPerTask.get(row.taskId);
-    if (!existing || row.sequence > existing.sequence) {
-      highestPerTask.set(row.taskId, {
-        stageName: row.stageName,
-        sequence: row.sequence,
-        currentPipelineStage: row.currentPipelineStage ?? null
-      });
-    }
-  }
-  const changes = [];
-  for (const [taskId, { stageName, sequence, currentPipelineStage }] of highestPerTask) {
-    const currentOrder = currentPipelineStage ? STAGE_ORDER3[currentPipelineStage] ?? 0 : 0;
-    if (sequence > currentOrder) {
-      changes.push({
-        taskId,
-        previousStage: currentPipelineStage,
-        newStage: stageName
-      });
-    }
-  }
-  const tasksScanned = highestPerTask.size;
-  if (!dryRun && changes.length > 0) {
-    const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    for (const change of changes) {
-      await db.update(tasks).set({
-        pipelineStage: change.newStage,
-        updatedAt: now2
-      }).where(eq15(tasks.id, change.taskId)).run();
-    }
-  }
-  if (!dryRun) {
-    const guardValue = JSON.stringify({
-      ranAt: (/* @__PURE__ */ new Date()).toISOString(),
-      tasksUpdated: changes.length,
-      task: "T869"
-    });
-    await db.insert(schemaMeta).values({ key: BACKFILL_KEY, value: guardValue }).onConflictDoUpdate({ target: schemaMeta.key, set: { value: guardValue } }).run();
-  }
-  return {
-    alreadyRun: false,
-    dryRun,
-    tasksScanned,
-    tasksUpdated: changes.length,
-    changes
-  };
-}
-async function isPipelineStageBackfillDone(cwd) {
-  const db = await getDb(cwd);
-  const guard = await db.select().from(schemaMeta).where(eq15(schemaMeta.key, BACKFILL_KEY)).limit(1).all();
-  return guard.length > 0;
-}
-var BACKFILL_KEY, STAGE_ORDER3;
-var init_backfill_pipeline_stage = __esm({
-  "packages/core/src/lifecycle/backfill-pipeline-stage.ts"() {
-    "use strict";
-    init_sqlite2();
-    init_tasks_schema();
-    BACKFILL_KEY = "backfill:pipeline-stage-from-lifecycle";
-    STAGE_ORDER3 = {
-      research: 1,
-      consensus: 2,
-      architecture_decision: 3,
-      specification: 4,
-      decomposition: 5,
-      implementation: 6,
-      validation: 7,
-      testing: 8,
-      release: 9,
-      contribution: 10
-    };
-  }
-});
-
 // packages/core/src/validation/chain-validation.ts
 function validateChainShape(shape) {
   const errors = [];
@@ -107194,9 +107107,9 @@ async function addChain(chain, projectRoot) {
 }
 async function showChain(id2, projectRoot) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
-  const rows = await db.select().from(warpChains).where(eq21(warpChains.id, id2));
+  const rows = await db.select().from(warpChains).where(eq20(warpChains.id, id2));
   if (rows.length === 0) return null;
   return JSON.parse(rows[0].definition);
 }
@@ -107243,9 +107156,9 @@ async function createInstance(params2, projectRoot) {
 }
 async function showInstance(id2, projectRoot) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
-  const rows = await db.select().from(warpChainInstances).where(eq21(warpChainInstances.id, id2));
+  const rows = await db.select().from(warpChainInstances).where(eq20(warpChainInstances.id, id2));
   if (rows.length === 0) return null;
   const row = rows[0];
   return {
@@ -107291,11 +107204,11 @@ async function advanceInstance(id2, nextStage, gateResults, projectRoot) {
     }
   }
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const existingResults = [];
-  const row = (await db.select().from(warpChainInstances).where(eq21(warpChainInstances.id, id2)))[0];
+  const row = (await db.select().from(warpChainInstances).where(eq20(warpChainInstances.id, id2)))[0];
   if (row?.gateResults) {
     existingResults.push(...JSON.parse(row.gateResults));
   }
@@ -107305,7 +107218,7 @@ async function advanceInstance(id2, nextStage, gateResults, projectRoot) {
     gateResults: JSON.stringify(allResults),
     status: "active",
     updatedAt: now2
-  }).where(eq21(warpChainInstances.id, id2));
+  }).where(eq20(warpChainInstances.id, id2));
   return {
     ...instance,
     currentStage: nextStage,
@@ -107830,7 +107743,7 @@ var init_gate_runner = __esm({
 
 // packages/core/src/lifecycle/ivtr-loop.ts
 import { createHash as createHash20 } from "node:crypto";
-import { eq as eq16 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 function nextPhase(current) {
   const idx = PHASE_ORDER.indexOf(current);
   if (idx === -1 || idx >= PHASE_ORDER.length - 1) return null;
@@ -107838,7 +107751,7 @@ function nextPhase(current) {
 }
 async function readIvtrStateRaw(taskId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select({ ivtrState: tasks.ivtrState }).from(tasks).where(eq16(tasks.id, taskId)).all();
+  const rows = await db.select({ ivtrState: tasks.ivtrState }).from(tasks).where(eq15(tasks.id, taskId)).all();
   if (rows.length === 0 || rows[0]?.ivtrState == null) return null;
   try {
     return JSON.parse(rows[0].ivtrState);
@@ -107849,12 +107762,12 @@ async function readIvtrStateRaw(taskId, cwd) {
 }
 async function writeIvtrState(state, cwd) {
   const db = await getDb(cwd);
-  const exists2 = await db.select({ id: tasks.id }).from(tasks).where(eq16(tasks.id, state.taskId)).get();
+  const exists2 = await db.select({ id: tasks.id }).from(tasks).where(eq15(tasks.id, state.taskId)).get();
   if (!exists2) {
     throw new Error(`Task ${state.taskId} not found --- cannot write IVTR state`);
   }
   const json3 = JSON.stringify(state);
-  await db.update(tasks).set({ ivtrState: json3, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq16(tasks.id, state.taskId)).run();
+  await db.update(tasks).set({ ivtrState: json3, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq15(tasks.id, state.taskId)).run();
 }
 async function startIvtr(taskId, options) {
   const existing = await readIvtrStateRaw(taskId, options?.cwd);
@@ -107995,7 +107908,7 @@ async function releaseIvtr(taskId, options) {
   state.currentPhase = "released";
   await writeIvtrState(state, options?.cwd);
   const db = await getDb(options?.cwd);
-  await db.update(tasks).set({ status: "done", completedAt: now2, updatedAt: now2 }).where(eq16(tasks.id, taskId)).all();
+  await db.update(tasks).set({ status: "done", completedAt: now2, updatedAt: now2 }).where(eq15(tasks.id, taskId)).all();
   log11.info({ taskId }, "IVTR released --- task marked done");
   return { released: true };
 }
@@ -109749,7 +109662,7 @@ var init_brain_maintenance = __esm({
 });
 
 // packages/core/src/memory/brain-purge.ts
-import { inArray as inArray7, ne as ne3, sql as sql15 } from "drizzle-orm";
+import { inArray as inArray6, ne as ne3, sql as sql15 } from "drizzle-orm";
 function countRowsNative(tableName) {
   const nativeDb = getBrainNativeDb();
   if (!nativeDb) return 0;
@@ -109798,7 +109711,7 @@ async function purgeBrainNoise(projectRoot) {
     const BATCH = 500;
     for (let i = 0; i < patternIdsToDelete.length; i += BATCH) {
       const batch = patternIdsToDelete.slice(i, i + BATCH);
-      await db.delete(brainPatterns).where(inArray7(brainPatterns.id, batch));
+      await db.delete(brainPatterns).where(inArray6(brainPatterns.id, batch));
       patternsDeleted += batch.length;
     }
   }
@@ -109810,7 +109723,7 @@ async function purgeBrainNoise(projectRoot) {
     const BATCH = 500;
     for (let i = 0; i < ids.length; i += BATCH) {
       const batch = ids.slice(i, i + BATCH);
-      await db.delete(brainLearnings).where(inArray7(brainLearnings.id, batch));
+      await db.delete(brainLearnings).where(inArray6(brainLearnings.id, batch));
     }
   }
   console.log(`Learnings deleted (all): ${learningsDeleted}`);
@@ -109818,7 +109731,7 @@ async function purgeBrainNoise(projectRoot) {
   const decisionsDeleted = decisionsToDelete.length;
   if (decisionsDeleted > 0) {
     const ids = decisionsToDelete.map((r) => r.id);
-    await db.delete(brainDecisions).where(inArray7(brainDecisions.id, ids));
+    await db.delete(brainDecisions).where(inArray6(brainDecisions.id, ids));
   }
   console.log(`Decisions deleted (all except D-mntpeeer): ${decisionsDeleted}`);
   const allObservations = await db.select().from(brainObservations);
@@ -109865,7 +109778,7 @@ async function purgeBrainNoise(projectRoot) {
     const BATCH = 500;
     for (let i = 0; i < obsIdsToDelete.length; i += BATCH) {
       const batch = obsIdsToDelete.slice(i, i + BATCH);
-      await db.delete(brainObservations).where(inArray7(brainObservations.id, batch));
+      await db.delete(brainObservations).where(inArray6(brainObservations.id, batch));
       observationsDeleted += batch.length;
     }
   }
@@ -111817,7 +111730,7 @@ var init_engine_compat = __esm({
 import { createHash as createHash22 } from "node:crypto";
 import { existsSync as existsSync113, readFileSync as readFileSync82, renameSync as renameSync8 } from "node:fs";
 import { join as join114 } from "node:path";
-import { and as and13, count as count3, desc as desc6, eq as eq17, gte as gte3, isNull as isNull3, like as like3, lte as lte2, or as or5 } from "drizzle-orm";
+import { and as and13, count as count3, desc as desc6, eq as eq16, gte as gte3, isNull as isNull3, like as like3, lte as lte2, or as or5 } from "drizzle-orm";
 async function getDb3(cwd) {
   const { getDb: _getDb } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
   return _getDb(cwd);
@@ -111839,10 +111752,10 @@ function buildManifestSqlFilters(filter) {
   const conditions = [isNull3(pipelineManifest.archivedAt)];
   if (filter.status) {
     const storedStatus = filter.status === "completed" ? "active" : filter.status;
-    conditions.push(eq17(pipelineManifest.status, storedStatus));
+    conditions.push(eq16(pipelineManifest.status, storedStatus));
   }
   if (filter.agent_type) {
-    conditions.push(eq17(pipelineManifest.type, filter.agent_type));
+    conditions.push(eq16(pipelineManifest.type, filter.agent_type));
   }
   if (filter.dateAfter) {
     conditions.push(gte3(pipelineManifest.createdAt, `${filter.dateAfter} 00:00:00`));
@@ -111935,7 +111848,7 @@ async function pipelineManifestShow(researchId, projectRoot) {
   }
   try {
     const db = await getDb3(projectRoot);
-    const rows = await db.select().from(pipelineManifest).where(eq17(pipelineManifest.id, researchId)).limit(1);
+    const rows = await db.select().from(pipelineManifest).where(eq16(pipelineManifest.id, researchId)).limit(1);
     if (rows.length === 0) {
       return {
         success: false,
@@ -112218,7 +112131,7 @@ async function pipelineManifestArchive(beforeDate, projectRoot) {
     }
     const archivedAt = now();
     for (const row of toArchive) {
-      await db.update(pipelineManifest).set({ archivedAt }).where(eq17(pipelineManifest.id, row.id));
+      await db.update(pipelineManifest).set({ archivedAt }).where(eq16(pipelineManifest.id, row.id));
     }
     const remaining = rows.length - toArchive.length;
     return { success: true, data: { archived: toArchive.length, remaining } };
@@ -112567,25 +112480,25 @@ async function measureTokenExchange(input) {
   );
 }
 async function whereClauses(filters) {
-  const { eq: eq21, gte: gte4, lte: lte3 } = await import("drizzle-orm");
+  const { eq: eq20, gte: gte4, lte: lte3 } = await import("drizzle-orm");
   const clauses = [];
-  if (filters.provider) clauses.push(eq21(tokenUsage.provider, filters.provider));
-  if (filters.transport) clauses.push(eq21(tokenUsage.transport, filters.transport));
-  if (filters.gateway) clauses.push(eq21(tokenUsage.gateway, filters.gateway));
-  if (filters.domain) clauses.push(eq21(tokenUsage.domain, filters.domain));
-  if (filters.operation) clauses.push(eq21(tokenUsage.operation, filters.operation));
-  if (filters.sessionId) clauses.push(eq21(tokenUsage.sessionId, filters.sessionId));
-  if (filters.taskId) clauses.push(eq21(tokenUsage.taskId, filters.taskId));
-  if (filters.method) clauses.push(eq21(tokenUsage.method, filters.method));
-  if (filters.confidence) clauses.push(eq21(tokenUsage.confidence, filters.confidence));
-  if (filters.requestId) clauses.push(eq21(tokenUsage.requestId, filters.requestId));
+  if (filters.provider) clauses.push(eq20(tokenUsage.provider, filters.provider));
+  if (filters.transport) clauses.push(eq20(tokenUsage.transport, filters.transport));
+  if (filters.gateway) clauses.push(eq20(tokenUsage.gateway, filters.gateway));
+  if (filters.domain) clauses.push(eq20(tokenUsage.domain, filters.domain));
+  if (filters.operation) clauses.push(eq20(tokenUsage.operation, filters.operation));
+  if (filters.sessionId) clauses.push(eq20(tokenUsage.sessionId, filters.sessionId));
+  if (filters.taskId) clauses.push(eq20(tokenUsage.taskId, filters.taskId));
+  if (filters.method) clauses.push(eq20(tokenUsage.method, filters.method));
+  if (filters.confidence) clauses.push(eq20(tokenUsage.confidence, filters.confidence));
+  if (filters.requestId) clauses.push(eq20(tokenUsage.requestId, filters.requestId));
   if (filters.since) clauses.push(gte4(tokenUsage.createdAt, filters.since));
   if (filters.until) clauses.push(lte3(tokenUsage.createdAt, filters.until));
   return clauses;
 }
 async function recordTokenExchange(input) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const measurement = await measureTokenExchange(input);
   const db = await getDb4(input.cwd);
   const row = {
@@ -112614,14 +112527,14 @@ async function recordTokenExchange(input) {
     })
   };
   await db.insert(tokenUsage).values(row);
-  const inserted = await db.select().from(tokenUsage).where(eq21(tokenUsage.id, row.id)).limit(1);
+  const inserted = await db.select().from(tokenUsage).where(eq20(tokenUsage.id, row.id)).limit(1);
   return inserted[0];
 }
 async function showTokenUsage(id2, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
-  const rows = await db.select().from(tokenUsage).where(eq21(tokenUsage.id, id2)).limit(1);
+  const rows = await db.select().from(tokenUsage).where(eq20(tokenUsage.id, id2)).limit(1);
   return rows[0] ?? null;
 }
 async function listTokenUsage(filters = {}, cwd) {
@@ -112689,9 +112602,9 @@ async function summarizeTokenUsage(filters = {}, cwd) {
 }
 async function deleteTokenUsage(id2, cwd) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(cwd);
-  await db.delete(tokenUsage).where(eq21(tokenUsage.id, id2));
+  await db.delete(tokenUsage).where(eq20(tokenUsage.id, id2));
   return { deleted: true, id: id2 };
 }
 async function clearTokenUsage(filters = {}, cwd) {
@@ -117002,7 +116915,7 @@ __export(session_store_exports, {
   updateSession: () => updateSession,
   workHistory: () => workHistory
 });
-import { and as and14, desc as desc7, eq as eq18, isNull as isNull4 } from "drizzle-orm";
+import { and as and14, desc as desc7, eq as eq17, isNull as isNull4 } from "drizzle-orm";
 async function createSession(session, cwd) {
   const db = await getDb(cwd);
   const tw = session.taskWork;
@@ -117024,7 +116937,7 @@ async function createSession(session, cwd) {
 }
 async function getSession(sessionId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(sessions).where(eq18(sessions.id, sessionId)).all();
+  const rows = await db.select().from(sessions).where(eq17(sessions.id, sessionId)).all();
   if (rows.length === 0) return null;
   return rowToSession(rows[0]);
 }
@@ -117053,14 +116966,14 @@ async function updateSession(sessionId, updates, cwd) {
     updateRow.handoffConsumedBy = updates.handoffConsumedBy;
   if (updates.debriefJson !== void 0) updateRow.debriefJson = updates.debriefJson;
   if (updates.handoffJson !== void 0) updateRow.handoffJson = updates.handoffJson;
-  db.update(sessions).set(updateRow).where(eq18(sessions.id, sessionId)).run();
+  db.update(sessions).set(updateRow).where(eq17(sessions.id, sessionId)).run();
   return getSession(sessionId, cwd);
 }
 async function listSessions2(filters, cwd) {
   const db = await getDb(cwd);
   const conditions = [];
   if (filters?.active) {
-    conditions.push(eq18(sessions.status, "active"));
+    conditions.push(eq17(sessions.status, "active"));
   }
   const query = db.select().from(sessions).where(conditions.length > 0 ? and14(...conditions) : void 0).orderBy(desc7(sessions.startedAt));
   const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
@@ -117085,19 +116998,19 @@ async function startTask2(sessionId, taskId, cwd) {
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.update(taskWorkHistory).set({ clearedAt: now2 }).where(
     and14(
-      eq18(taskWorkHistory.sessionId, sessionId),
+      eq17(taskWorkHistory.sessionId, sessionId),
       isNull4(taskWorkHistory.clearedAt)
     )
   ).run();
   db.insert(taskWorkHistory).values({ sessionId, taskId, setAt: now2 }).run();
-  db.update(sessions).set({ currentTask: taskId, taskStartedAt: now2 }).where(eq18(sessions.id, sessionId)).run();
+  db.update(sessions).set({ currentTask: taskId, taskStartedAt: now2 }).where(eq17(sessions.id, sessionId)).run();
 }
 async function getCurrentTask(sessionId, cwd) {
   const db = await getDb(cwd);
   const rows = await db.select({
     currentTask: sessions.currentTask,
     taskStartedAt: sessions.taskStartedAt
-  }).from(sessions).where(eq18(sessions.id, sessionId)).all();
+  }).from(sessions).where(eq17(sessions.id, sessionId)).all();
   if (rows.length === 0) return { taskId: null, since: null };
   return { taskId: rows[0].currentTask, since: rows[0].taskStartedAt };
 }
@@ -117106,15 +117019,15 @@ async function stopTask2(sessionId, cwd) {
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   db.update(taskWorkHistory).set({ clearedAt: now2 }).where(
     and14(
-      eq18(taskWorkHistory.sessionId, sessionId),
+      eq17(taskWorkHistory.sessionId, sessionId),
       isNull4(taskWorkHistory.clearedAt)
     )
   ).run();
-  db.update(sessions).set({ currentTask: null, taskStartedAt: null }).where(eq18(sessions.id, sessionId)).run();
+  db.update(sessions).set({ currentTask: null, taskStartedAt: null }).where(eq17(sessions.id, sessionId)).run();
 }
 async function workHistory(sessionId, limit = 50, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskWorkHistory).where(eq18(taskWorkHistory.sessionId, sessionId)).orderBy(desc7(taskWorkHistory.setAt), desc7(taskWorkHistory.id)).limit(limit).all();
+  const rows = await db.select().from(taskWorkHistory).where(eq17(taskWorkHistory.sessionId, sessionId)).orderBy(desc7(taskWorkHistory.setAt), desc7(taskWorkHistory.id)).limit(limit).all();
   return rows.map((r) => ({
     taskId: r.taskId,
     setAt: r.setAt,
@@ -117125,16 +117038,16 @@ async function gcSessions2(maxAgeDays = 30, cwd) {
   const db = await getDb(cwd);
   const threshold = /* @__PURE__ */ new Date();
   threshold.setDate(threshold.getDate() - maxAgeDays);
-  const before = await db.select({ id: sessions.id }).from(sessions).where(and14(eq18(sessions.status, "ended"))).all();
+  const before = await db.select({ id: sessions.id }).from(sessions).where(and14(eq17(sessions.status, "ended"))).all();
   const toUpdate = before;
   if (toUpdate.length > 0) {
-    db.update(sessions).set({ status: "orphaned" }).where(eq18(sessions.status, "ended")).run();
+    db.update(sessions).set({ status: "orphaned" }).where(eq17(sessions.status, "ended")).run();
   }
   return toUpdate.length;
 }
 async function getActiveSession(cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(sessions).where(eq18(sessions.status, "active")).orderBy(desc7(sessions.startedAt)).limit(1).all();
+  const rows = await db.select().from(sessions).where(eq17(sessions.status, "active")).orderBy(desc7(sessions.startedAt)).limit(1).all();
   if (rows.length === 0) return null;
   return rowToSession(rows[0]);
 }
@@ -117148,12 +117061,12 @@ var init_session_store = __esm({
 });
 
 // packages/core/src/store/data-safety.ts
-import { eq as eq19 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 async function checkTaskExists(taskId, cwd, config2 = {}) {
   const cfg = { ...DEFAULT_CONFIG2, ...config2 };
   if (!cfg.detectCollisions) return false;
   const db = await getDb(cwd);
-  const existing = await db.select().from(tasks).where(eq19(tasks.id, taskId)).all();
+  const existing = await db.select().from(tasks).where(eq18(tasks.id, taskId)).all();
   const exists2 = existing.length > 0;
   if (exists2 && cfg.strictMode) {
     throw new SafetyError(
@@ -117303,7 +117216,7 @@ __export(task_store_exports, {
   updateTask: () => updateTask2,
   updateTaskSafe: () => updateTaskSafe
 });
-import { and as and15, asc as asc4, count as count4, eq as eq20, inArray as inArray8, isNull as isNull5, ne as ne5, sql as sql16 } from "drizzle-orm";
+import { and as and15, asc as asc4, count as count4, eq as eq19, inArray as inArray7, isNull as isNull5, ne as ne5, sql as sql16 } from "drizzle-orm";
 async function insertTaskRow(task, cwd) {
   const db = await getDb(cwd);
   const row = taskToRow(task);
@@ -117317,10 +117230,10 @@ async function insertTaskRow(task, cwd) {
 }
 async function getTask(taskId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(tasks).where(eq20(tasks.id, taskId)).all();
+  const rows = await db.select().from(tasks).where(eq19(tasks.id, taskId)).all();
   if (rows.length === 0) return null;
   const task = rowToTask(rows[0]);
-  const deps = await db.select().from(taskDependencies).where(eq20(taskDependencies.taskId, taskId)).all();
+  const deps = await db.select().from(taskDependencies).where(eq19(taskDependencies.taskId, taskId)).all();
   if (deps.length > 0) {
     task.depends = deps.map((d) => d.dependsOn);
   }
@@ -117363,9 +117276,9 @@ async function updateTask2(taskId, updates, cwd) {
   if (updates.verification !== void 0)
     updateRow.verificationJson = JSON.stringify(updates.verification);
   if (updates.assignee !== void 0) updateRow.assignee = updates.assignee;
-  db.update(tasks).set(updateRow).where(eq20(tasks.id, taskId)).run();
+  db.update(tasks).set(updateRow).where(eq19(tasks.id, taskId)).run();
   if (updates.depends !== void 0) {
-    db.delete(taskDependencies).where(eq20(taskDependencies.taskId, taskId)).run();
+    db.delete(taskDependencies).where(eq19(taskDependencies.taskId, taskId)).run();
     for (const depId of updates.depends) {
       db.insert(taskDependencies).values({ taskId, dependsOn: depId }).run();
     }
@@ -117374,9 +117287,9 @@ async function updateTask2(taskId, updates, cwd) {
 }
 async function deleteTask2(taskId, cwd) {
   const db = await getDb(cwd);
-  const existing = await db.select({ id: tasks.id }).from(tasks).where(eq20(tasks.id, taskId)).all();
+  const existing = await db.select({ id: tasks.id }).from(tasks).where(eq19(tasks.id, taskId)).all();
   if (existing.length === 0) return false;
-  db.delete(tasks).where(eq20(tasks.id, taskId)).run();
+  db.delete(tasks).where(eq19(tasks.id, taskId)).run();
   void cleanupBrainRefsOnTaskDelete(taskId, cwd);
   return true;
 }
@@ -117384,16 +117297,16 @@ async function listTasks2(filters, cwd) {
   const db = await getDb(cwd);
   const conditions = [];
   conditions.push(ne5(tasks.status, "archived"));
-  if (filters?.status) conditions.push(eq20(tasks.status, filters.status));
+  if (filters?.status) conditions.push(eq19(tasks.status, filters.status));
   if (filters?.parentId !== void 0) {
     if (filters.parentId === null) {
       conditions.push(isNull5(tasks.parentId));
     } else {
-      conditions.push(eq20(tasks.parentId, filters.parentId));
+      conditions.push(eq19(tasks.parentId, filters.parentId));
     }
   }
-  if (filters?.type) conditions.push(eq20(tasks.type, filters.type));
-  if (filters?.phase) conditions.push(eq20(tasks.phase, filters.phase));
+  if (filters?.type) conditions.push(eq19(tasks.type, filters.type));
+  if (filters?.phase) conditions.push(eq19(tasks.phase, filters.phase));
   const query = db.select().from(tasks).where(conditions.length > 0 ? and15(...conditions) : void 0).orderBy(asc4(tasks.position), asc4(tasks.createdAt));
   const rows = filters?.limit ? await query.limit(filters.limit).all() : await query.all();
   const tasks2 = rows.map(rowToTask);
@@ -117423,14 +117336,14 @@ async function archiveTask(taskId, reason, cwd) {
     archiveReason: reason ?? "completed",
     cycleTimeDays: cycleTime,
     updatedAt: now2
-  }).where(eq20(tasks.id, taskId)).run();
+  }).where(eq19(tasks.id, taskId)).run();
   return true;
 }
 async function loadDependencies(tasks2, cwd) {
   if (tasks2.length === 0) return;
   const db = await getDb(cwd);
   const taskIds = tasks2.map((t) => t.id);
-  const deps = await db.select().from(taskDependencies).where(inArray8(taskDependencies.taskId, taskIds)).all();
+  const deps = await db.select().from(taskDependencies).where(inArray7(taskDependencies.taskId, taskIds)).all();
   const depMap = /* @__PURE__ */ new Map();
   for (const dep of deps) {
     if (!depMap.has(dep.taskId)) depMap.set(dep.taskId, []);
@@ -117451,8 +117364,8 @@ async function removeDependency(taskId, dependsOn, cwd) {
   const db = await getDb(cwd);
   db.delete(taskDependencies).where(
     and15(
-      eq20(taskDependencies.taskId, taskId),
-      eq20(taskDependencies.dependsOn, dependsOn)
+      eq19(taskDependencies.taskId, taskId),
+      eq19(taskDependencies.dependsOn, dependsOn)
     )
   ).run();
 }
@@ -117462,7 +117375,7 @@ async function addRelation(taskId, relatedTo, relationType = "related", cwd, rea
 }
 async function getRelations(taskId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(taskRelations).where(eq20(taskRelations.taskId, taskId)).all();
+  const rows = await db.select().from(taskRelations).where(eq19(taskRelations.taskId, taskId)).all();
   return rows.map((r) => ({
     relatedTo: r.relatedTo,
     type: r.relationType,
@@ -117486,7 +117399,7 @@ async function getBlockerChain(taskId, cwd) {
 }
 async function getChildren2(parentId, cwd) {
   const db = await getDb(cwd);
-  const rows = await db.select().from(tasks).where(eq20(tasks.parentId, parentId)).orderBy(asc4(tasks.position), asc4(tasks.createdAt)).all();
+  const rows = await db.select().from(tasks).where(eq19(tasks.parentId, parentId)).orderBy(asc4(tasks.position), asc4(tasks.createdAt)).all();
   return rows.map(rowToTask);
 }
 async function getSubtree(rootId, cwd) {
@@ -117611,6 +117524,7 @@ function canCancel(task) {
 var init_cancel_ops = __esm({
   "packages/core/src/tasks/cancel-ops.ts"() {
     "use strict";
+    init_pipeline_stage();
   }
 });
 
@@ -117982,6 +117896,9 @@ async function coreTaskRestore(projectRoot, taskId, params2) {
     t.cancelledAt = void 0;
     t.cancellationReason = void 0;
     t.updatedAt = now2;
+    if (t.pipelineStage === "cancelled") {
+      t.pipelineStage = t.type === "epic" ? "research" : "implementation";
+    }
     if (!t.notes) t.notes = [];
     t.notes.push(`[${now2}] Restored from cancelled${params2?.notes ? ": " + params2.notes : ""}`);
     restored.push(t.id);
@@ -118006,6 +117923,9 @@ async function coreTaskCancel(projectRoot, taskId, params2) {
   task.cancelledAt = cancelledAt;
   task.cancellationReason = params2?.reason ?? void 0;
   task.updatedAt = cancelledAt;
+  if (!isTerminalPipelineStage(task.pipelineStage)) {
+    task.pipelineStage = "cancelled";
+  }
   await accessor.upsertSingleTask(task);
   return { task: taskId, cancelled: true, reason: params2?.reason, cancelledAt };
 }
@@ -118708,6 +118628,7 @@ var init_task_ops = __esm({
     init_cancel_ops();
     init_dependency_check();
     init_deps_ready();
+    init_pipeline_stage();
     PRIORITY_SCORE2 = {
       critical: 100,
       high: 75,
@@ -118886,6 +118807,7 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
       for (let i = 0; i < tasks2.length; i++) {
         const task = tasks2[i];
         try {
+          const importedPipelineStage = task.pipelineStage ?? (task.status === "done" ? "contribution" : task.status === "cancelled" ? "cancelled" : null);
           await db.insert(tasks).values({
             id: task.id,
             title: task.title,
@@ -118913,7 +118835,8 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
             verificationJson: task.verification ? JSON.stringify(task.verification) : void 0,
             createdBy: task.provenance?.createdBy,
             modifiedBy: task.provenance?.modifiedBy,
-            sessionId: task.provenance?.sessionId
+            sessionId: task.provenance?.sessionId,
+            pipelineStage: importedPipelineStage
           }).onConflictDoNothing().run();
           if (task.depends) {
             for (const depId of task.depends) {
@@ -119095,10 +119018,10 @@ async function migrateJsonToSqlite2(cwd, options) {
   const jsonCounts = countJsonRecords(cleoDir);
   result.jsonCounts = jsonCounts;
   if (dbExists(cwd)) {
-    const { ne: ne6, eq: eq21, count: count5 } = await import("drizzle-orm");
+    const { ne: ne6, eq: eq20, count: count5 } = await import("drizzle-orm");
     const db2 = await getDb(cwd);
     const tasksResult = await db2.select({ count: count5() }).from(tasks).where(ne6(tasks.status, "archived")).get();
-    const archivedResult = await db2.select({ count: count5() }).from(tasks).where(eq21(tasks.status, "archived")).get();
+    const archivedResult = await db2.select({ count: count5() }).from(tasks).where(eq20(tasks.status, "archived")).get();
     const sessionsResult = await db2.select({ count: count5() }).from(sessions).get();
     const existingCounts = {
       tasks: tasksResult?.count ?? 0,
@@ -119160,6 +119083,7 @@ async function migrateJsonToSqlite2(cwd, options) {
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       for (const task of tasks2) {
         try {
+          const importedPipelineStage = task.pipelineStage ?? (task.status === "done" ? "contribution" : task.status === "cancelled" ? "cancelled" : null);
           db.insert(tasks).values({
             id: task.id,
             title: task.title,
@@ -119187,7 +119111,8 @@ async function migrateJsonToSqlite2(cwd, options) {
             verificationJson: task.verification ? JSON.stringify(task.verification) : void 0,
             createdBy: task.provenance?.createdBy,
             modifiedBy: task.provenance?.modifiedBy,
-            sessionId: task.provenance?.sessionId
+            sessionId: task.provenance?.sessionId,
+            pipelineStage: importedPipelineStage
           }).onConflictDoNothing().run();
           if (task.depends) {
             for (const depId of task.depends) {
@@ -119282,10 +119207,10 @@ async function migrateJsonToSqlite2(cwd, options) {
 async function exportToJson(cwd) {
   const { listTasks: listTasks3 } = await Promise.resolve().then(() => (init_task_store(), task_store_exports));
   const { listSessions: listSessions3 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
-  const { eq: eq21 } = await import("drizzle-orm");
+  const { eq: eq20 } = await import("drizzle-orm");
   const tasks2 = await listTasks3(void 0, cwd);
   const db = await getDb(cwd);
-  const archivedRows = await db.select().from(tasks).where(eq21(tasks.status, "archived")).all();
+  const archivedRows = await db.select().from(tasks).where(eq20(tasks.status, "archived")).all();
   const archived = archivedRows.map((row) => ({
     id: row.id,
     title: row.title,
@@ -122196,7 +122121,7 @@ async function validateSqliteRows(type, projectRoot) {
   const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
   const schemaTable = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
   const zodSchemas = await Promise.resolve().then(() => (init_validation_schemas(), validation_schemas_exports));
-  const { ne: ne6, eq: eq21 } = await import("drizzle-orm");
+  const { ne: ne6, eq: eq20 } = await import("drizzle-orm");
   const db = await getDb4(projectRoot);
   const errors = [];
   switch (type) {
@@ -122208,7 +122133,7 @@ async function validateSqliteRows(type, projectRoot) {
       break;
     }
     case "archive": {
-      const rows = await db.select().from(schemaTable.tasks).where(eq21(schemaTable.tasks.status, "archived"));
+      const rows = await db.select().from(schemaTable.tasks).where(eq20(schemaTable.tasks.status, "archived"));
       for (const row of rows) {
         errors.push(...collectZodErrors(zodSchemas.selectTaskSchema.safeParse(row), row.id));
       }
@@ -132144,7 +132069,6 @@ __export(internal_exports, {
   MINIMUM_NODE_MAJOR: () => MINIMUM_NODE_MAJOR,
   OrchestrationLevel: () => OrchestrationLevel,
   PIPELINE_STAGES: () => PIPELINE_STAGES,
-  PIPELINE_STAGE_BACKFILL_KEY: () => BACKFILL_KEY,
   PIPELINE_STATUS_ICONS: () => PIPELINE_STATUS_ICONS,
   PLATFORM: () => PLATFORM,
   PROTOCOL_RULES: () => PROTOCOL_RULES,
@@ -132228,7 +132152,6 @@ __export(internal_exports, {
   autoRecordDispatchTokenUsage: () => autoRecordDispatchTokenUsage,
   autoRunGatesAndRecord: () => autoRunGatesAndRecord,
   backfillBrainGraph: () => backfillBrainGraph,
-  backfillPipelineStageFromLifecycle: () => backfillPipelineStageFromLifecycle,
   backfillTasks: () => backfillTasks,
   backupGlobalSalt: () => backupGlobalSalt,
   batchParse: () => batchParse,
@@ -132655,7 +132578,6 @@ __export(internal_exports, {
   isLafsSuccess: () => isLafsSuccess,
   isNoChangeCode: () => isNoChangeCode,
   isOverloaded: () => isOverloaded,
-  isPipelineStageBackfillDone: () => isPipelineStageBackfillDone,
   isPipelineTransitionForward: () => isPipelineTransitionForward,
   isProjectInitialized: () => isProjectInitialized,
   isProviderHookEvent: () => isProviderHookEvent,
@@ -133062,7 +132984,6 @@ var init_internal = __esm({
     init_create();
     init_diagnostics();
     init_retry2();
-    init_backfill_pipeline_stage();
     init_chain_store();
     init_lifecycle2();
     init_ivtr_loop();
@@ -141470,10 +141391,10 @@ async function releaseShip(params2, projectRoot) {
         );
         const { getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
         const { releaseManifests: releaseManifests2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-        const { eq: eq21 } = await import("drizzle-orm");
+        const { eq: eq20 } = await import("drizzle-orm");
         const normalizedVer = version2.startsWith("v") ? version2 : `v${version2}`;
         const db = await getDb4(cwd);
-        await db.update(releaseManifests2).set({ epicId }).where(eq21(releaseManifests2.version, normalizedVer)).run();
+        await db.update(releaseManifests2).set({ epicId }).where(eq20(releaseManifests2.version, normalizedVer)).run();
         await generateReleaseChangelog(version2, () => loadTasks2(projectRoot), cwd);
       }
       logStep(0, 8, "Auto-prepare release record", true);
@@ -145742,12 +145663,12 @@ function scanForbiddenPhrases(filePath, lines) {
 }
 function countCanonicalDomains(typesFilePath) {
   const lines = readLines(typesFilePath);
-  let inArray9 = false;
+  let inArray8 = false;
   let count5 = 0;
   for (const line2 of lines) {
-    if (!inArray9) {
+    if (!inArray8) {
       if (line2.includes("CANONICAL_DOMAINS") && line2.includes("[")) {
-        inArray9 = true;
+        inArray8 = true;
       }
       continue;
     }
@@ -155485,7 +155406,9 @@ var adminCommand = defineCommand({
     "install-global": installGlobalCommand,
     "context-inject": contextInjectCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -155623,7 +155546,9 @@ var adrCommand = defineCommand({
     sync: syncCommand,
     find: findCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -157811,7 +157736,9 @@ var agentCommand = defineCommand({
     pack: packCommand,
     create: createCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -159535,7 +159462,9 @@ var brainCommand = defineCommand({
     quality: qualityCommand,
     export: exportCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -159896,7 +159825,9 @@ var cantCommand = defineCommand({
     execute: cantExecuteCommand,
     migrate: cantMigrateCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -160006,7 +159937,9 @@ var chainCommand = defineCommand({
     instantiate: instantiateCommand,
     advance: advanceCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -160276,7 +160209,9 @@ var checkCommand = defineCommand({
     canon: checkCanonCommand,
     protocol: checkProtocolCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -160622,7 +160557,9 @@ var complexityEstimateCommand = defineCommand({
 var complexityCommand = defineCommand({
   meta: { name: "complexity", description: "Task complexity analysis" },
   subCommands: { estimate: complexityEstimateCommand },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -160865,7 +160802,9 @@ var complianceCommand = defineCommand({
     value: valueCommand,
     record: recordCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -161010,7 +160949,9 @@ var conduitCommand = defineCommand({
     stop: stopCommand2,
     send: sendCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -161128,7 +161069,9 @@ var configCommand = defineCommand({
     presets: presetsCommand,
     list: listCommand6
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -161216,7 +161159,9 @@ var consensusCommand = defineCommand({
     validate: validateCommand2,
     check: checkCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -161413,7 +161358,9 @@ var contributionCommand = defineCommand({
     validate: validateCommand3,
     check: checkCommand4
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -162161,7 +162108,9 @@ var decompositionCommand = defineCommand({
     validate: validateCommand4,
     check: checkCommand5
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -162341,7 +162290,9 @@ var depsCommand = defineCommand({
     impact: impactCommand,
     cycles: cyclesCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -162850,7 +162801,9 @@ var diagnosticsCommand = defineCommand({
     analyze: analyzeCommand2,
     export: exportCommand3
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -163200,7 +163153,9 @@ var docsCommand = defineCommand({
     sync: syncCommand3,
     "gap-check": gapCheckCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -163848,7 +163803,9 @@ var gcCommand = defineCommand({
     run: runCommand3,
     status: statusCommand6
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -164156,7 +164113,9 @@ var historyCommand = defineCommand({
     log: logCommand,
     work: workCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -164558,7 +164517,9 @@ var intelligenceCommand = defineCommand({
     confidence: confidenceCommand,
     match: matchCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -164679,7 +164640,9 @@ var issueCommand = defineCommand({
     help: helpCommand,
     diagnostics: diagnosticsCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -164956,7 +164919,9 @@ var lifecycleCommand = defineCommand({
     reset: resetCommand,
     "gate-record": gateRecordCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -167053,7 +167018,9 @@ var memoryBrainCommand = defineCommand({
     "pending-verify": pendingVerifyCommand,
     tier: tierCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -167151,7 +167118,9 @@ var migrateClaudeMemCommand = defineCommand({
     "claude-mem": claudeMemCommand,
     storage: storageCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -168673,7 +168642,7 @@ var analyzeCommand3 = defineCommand({
       );
     }
     try {
-      const [{ getNexusDb: getNexusDb2, nexusSchema }, { runPipeline: runPipeline2 }, { getProjectRoot: getProjectRoot4 }, { eq: eq21 }] = await Promise.all([
+      const [{ getNexusDb: getNexusDb2, nexusSchema }, { runPipeline: runPipeline2 }, { getProjectRoot: getProjectRoot4 }, { eq: eq20 }] = await Promise.all([
         import("@cleocode/core/store/nexus-sqlite"),
         import("@cleocode/nexus/pipeline"),
         Promise.resolve().then(() => (init_internal(), internal_exports)),
@@ -168690,11 +168659,11 @@ var analyzeCommand3 = defineCommand({
           process.stderr.write("[nexus] Clearing existing index for project...\n");
         }
         try {
-          db.delete(nexusSchema.nexusNodes).where(eq21(nexusSchema.nexusNodes.projectId, projectId)).run();
+          db.delete(nexusSchema.nexusNodes).where(eq20(nexusSchema.nexusNodes.projectId, projectId)).run();
         } catch {
         }
         try {
-          db.delete(nexusSchema.nexusRelations).where(eq21(nexusSchema.nexusRelations.projectId, projectId)).run();
+          db.delete(nexusSchema.nexusRelations).where(eq20(nexusSchema.nexusRelations.projectId, projectId)).run();
         } catch {
         }
       }
@@ -169351,7 +169320,7 @@ var projectsCleanCommand = defineCommand({
       const { getNexusDb: getNexusDb2 } = await import("@cleocode/core/store/nexus-sqlite");
       const { projectRegistry: regTable, nexusAuditLog: auditTable } = await import("@cleocode/core/store/nexus-schema");
       const { randomUUID: randomUUID16 } = await import("node:crypto");
-      const { inArray: inArray9 } = await import("drizzle-orm");
+      const { inArray: inArray8 } = await import("drizzle-orm");
       const db = await getNexusDb2();
       const allRows = await db.select({
         projectId: regTable.projectId,
@@ -169461,7 +169430,7 @@ var projectsCleanCommand = defineCommand({
         }
       }
       const idsToDelete = matches.map((r) => r.projectId);
-      await db.delete(regTable).where(inArray9(regTable.projectId, idsToDelete));
+      await db.delete(regTable).where(inArray8(regTable.projectId, idsToDelete));
       const remaining = totalCount - matchCount;
       try {
         await db.insert(auditTable).values({
@@ -169956,7 +169925,9 @@ var nexusCommand = defineCommand({
     export: exportCommand5,
     diff: diffCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -170596,7 +170567,9 @@ var orchestrateCommand = defineCommand({
     "conduit-stop": conduitStopCommand,
     "conduit-send": conduitSendCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -170746,7 +170719,9 @@ var otelCommand = defineCommand({
     real: realCommand,
     clear: clearCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -170933,7 +170908,9 @@ var phaseCommand = defineCommand({
     rename: renameCommand,
     delete: deleteCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -171250,7 +171227,9 @@ var reasonCommand = defineCommand({
     impact: impactCommand3,
     timeline: timelineCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -171388,7 +171367,9 @@ var relatesCommand = defineCommand({
     discover: discoverCommand2,
     list: listCommand13
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -171605,7 +171586,9 @@ var releaseCommand = defineCommand({
     "rollback-full": rollbackFullCommand,
     channel: channelCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -171755,7 +171738,9 @@ var remoteCommand = defineCommand({
     list: listRemoteCommand,
     status: statusRemoteCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -172009,7 +171994,9 @@ var reqCommand = defineCommand({
     list: listCommand15,
     migrate: migrateCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -172336,7 +172323,9 @@ var researchCommand = defineCommand({
     archive: archiveCommand2,
     manifest: manifestCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -172811,7 +172800,9 @@ var restoreCommand = defineCommand({
     backup: backupSubCommand,
     task: taskSubCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -173492,7 +173483,9 @@ var sequenceCommand = defineCommand({
     check: checkCommand6,
     repair: repairCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -173964,7 +173957,9 @@ var sessionCommand = defineCommand({
     "record-decision": recordDecisionCommand,
     "decision-log": decisionLogCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -174416,7 +174411,9 @@ var snapshotCommand = defineCommand({
     export: exportCommand6,
     import: importCommand4
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -174793,7 +174790,9 @@ var stickyCommand = defineCommand({
     archive: archiveCommand3,
     purge: purgeCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -174918,7 +174917,9 @@ var syncCommand5 = defineCommand({
     links: linksCommand2,
     reconcile: reconcileCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -175031,7 +175032,9 @@ var testingCommand = defineCommand({
     coverage: coverageCommand,
     run: runCommand4
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -175217,7 +175220,9 @@ var tokenCommand = defineCommand({
     clear: clearCommand2,
     estimate: estimateCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -175906,7 +175911,9 @@ var transcriptCommand = defineCommand({
     migrate: migrateCommand2,
     prune: pruneCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });
@@ -176544,7 +176551,9 @@ var webCommand = defineCommand({
     status: statusCommand12,
     open: openCommand
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
     await showUsage(cmd);
   }
 });