@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/tasks-C24KHTFF.js

@@ -0,0 +1,1118 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch,
+  wrapCoreResult
+} from "./chunk-QWNKLLLG.js";
+import {
+  lazyOperation
+} from "./chunk-TYC7G5LF.js";
+import {
+  envelopeToEngineResult,
+  errorResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/tasks.ts
+import { TASKS_SUGGESTED_NEXT_BUILDERS } from "@cleocode/core/dispatch/suggested-next";
+import { getLogger } from "@cleocode/core/logger";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+var coreSagaAdd = lazyOperation(async () => (await import("@cleocode/core/sagas")).sagaAdd);
+var coreSagaCreate = lazyOperation(async () => (await import("@cleocode/core/sagas")).sagaCreate);
+var coreSagaDetach = lazyOperation(
+  async () => (await import("@cleocode/core/sagas")).detachSagaMember
+);
+var coreSagaList = lazyOperation(async () => (await import("@cleocode/core/sagas")).sagaList);
+var coreSagaMembers = lazyOperation(
+  async () => (await import("@cleocode/core/sagas")).sagaMembers
+);
+var coreSagaReconcile = lazyOperation(
+  async () => (await import("@cleocode/core/sagas")).reconcileSaga
+);
+var coreSagaRepair = lazyOperation(async () => (await import("@cleocode/core/sagas")).repairSaga);
+var coreSagaRollup = lazyOperation(async () => (await import("@cleocode/core/sagas")).sagaRollup);
+var taskCurrentGet = lazyOperation(
+  async () => (await import("@cleocode/core/session/task-current")).taskCurrentGet
+);
+var taskStart = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).taskStart
+);
+var taskStop = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).taskStop
+);
+var taskWorkHistory = lazyOperation(
+  async () => (await import("@cleocode/core/session/engine-ops")).taskWorkHistory
+);
+var reqAdd = lazyOperation(async () => (await import("@cleocode/core/tasks/req")).reqAdd);
+var reqList = lazyOperation(async () => (await import("@cleocode/core/tasks/req")).reqList);
+var reqMigrate = lazyOperation(async () => (await import("@cleocode/core/tasks/req")).reqMigrate);
+var tasksAddBatchOp = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/add-batch")).tasksAddBatchOp
+);
+var taskArchive = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/archive")).taskArchive
+);
+var completeTaskStrict = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/complete")).completeTaskStrict
+);
+var taskDecompose = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/decompose")).taskDecompose
+);
+var taskDelete = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/delete")).taskDelete
+);
+var taskAnalyze = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskAnalyze
+);
+var taskAssignee = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskAssignee
+);
+var taskBlockers = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskBlockers
+);
+var taskBulkMove = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskBulkMove
+);
+var taskCancel = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskCancel
+);
+var taskImpact = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskImpact
+);
+var taskNext = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskNext
+);
+var taskRelates = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskRelates
+);
+var taskRelatesAdd = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskRelatesAdd
+);
+var taskRelatesAddBatch = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskRelatesAddBatch
+);
+var taskRelatesFind = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskRelatesFind
+);
+var taskRelatesRemove = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskRelatesRemove
+);
+var taskReopen = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskReopen
+);
+var taskReorder = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskReorder
+);
+var taskReorderRank = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskReorderRank
+);
+var taskReparent = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskReparent
+);
+var taskRestore = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskRestore
+);
+var taskTree = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskTree
+);
+var taskUnarchive = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap")).taskUnarchive
+);
+var taskClaim = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskClaim
+);
+var taskComplexityEstimate = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskComplexityEstimate
+);
+var taskContext = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskContext
+);
+var taskDepends = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskDepends
+);
+var taskDepsCycles = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskDepsCycles
+);
+var taskDepsOverview = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskDepsOverview
+);
+var taskDepsTree = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskDepsTree
+);
+var taskDepsValidate = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskDepsValidate
+);
+var taskHistory = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskHistory
+);
+var taskRankingHistory = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskRankingHistory
+);
+var taskRankingRevert = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskRankingRevert
+);
+var taskSlice = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskSlice
+);
+var taskUnclaim = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/engine-wrap-ops")).taskUnclaim
+);
+var taskFind = lazyOperation(async () => (await import("@cleocode/core/tasks/find")).taskFind);
+var taskLabelList = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/labels")).taskLabelList
+);
+var taskList = lazyOperation(async () => (await import("@cleocode/core/tasks/list")).taskList);
+var taskPlan = lazyOperation(async () => (await import("@cleocode/core/tasks/plan")).taskPlan);
+var taskReconcileScope = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/reconcile-scope")).taskReconcileScope
+);
+var addTaskWithSessionScope = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/session-scope")).addTaskWithSessionScope
+);
+var taskShowOperation = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/show")).taskShowOperation
+);
+var taskSyncLinks = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/sync-ops")).taskSyncLinks
+);
+var taskSyncLinksRemove = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/sync-ops")).taskSyncLinksRemove
+);
+var taskSyncReconcile = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/sync-ops")).taskSyncReconcile
+);
+var taskUpdate = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/update")).taskUpdate
+);
+var _tasksTypedHandler = defineTypedHandler("tasks", {
+  // -------------------------------------------------------------------------
+  // Query ops
+  // -------------------------------------------------------------------------
+  show: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskShowOperation(projectRoot, params), "show");
+  },
+  list: async (params) => {
+    const projectRoot = getProjectRoot();
+    const result = await taskList(projectRoot, {
+      parent: params.parent,
+      status: params.status,
+      priority: params.priority,
+      type: params.type,
+      // T12120 (GH #1245/#1246) — these two axes were missing here as well as
+      // at every other layer of the relay; omitting them here silently drops
+      // the filter after the CLI has already accepted it.
+      severity: params.severity,
+      kind: params.kind,
+      phase: params.phase,
+      label: params.label,
+      children: params.children,
+      limit: params.limit,
+      offset: params.offset,
+      compact: params.compact,
+      includeArchive: params.includeArchive
+    });
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "list"
+      );
+    }
+    if (result.page) {
+      return { success: true, data: result.data, page: result.page };
+    }
+    return lafsSuccess(result.data, "list");
+  },
+  find: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskFind(projectRoot, params.query, params.limit, {
+        id: params.id,
+        exact: params.exact,
+        fuzzy: params.fuzzy,
+        field: params.field,
+        status: params.status,
+        includeArchive: params.includeArchive,
+        offset: params.offset,
+        fields: params.fields,
+        verbose: params.verbose,
+        // T944/T9072: kind filter
+        kind: params.kind,
+        // T9905: unified urgency surface
+        urgent: params.urgent,
+        // T9904: label filter — `cleo find --label <name>` (closes GH#393).
+        label: params.label,
+        // T10108: parent filter — `cleo find --parent <id>`. Saga-aware via
+        // resolveSagaMemberIds (ADR-073 §1) so saga members surface through
+        // the same routing as `cleo list --parent`.
+        parent: params.parent
+      }),
+      "find"
+    );
+  },
+  tree: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskTree(projectRoot, params.taskId, params.withBlockers), "tree");
+  },
+  blockers: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskBlockers(projectRoot, params), "blockers");
+  },
+  depends: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (params.action === "overview") {
+      return wrapCoreResult(await taskDepsOverview(projectRoot), "depends");
+    }
+    if (params.action === "cycles") {
+      return wrapCoreResult(await taskDepsCycles(projectRoot), "depends");
+    }
+    if (!params.taskId) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "taskId is required (or use action: overview|cycles)",
+        "depends"
+      );
+    }
+    return wrapCoreResult(
+      await taskDepends(projectRoot, params.taskId, params.direction, params.tree),
+      "depends"
+    );
+  },
+  slice: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskSlice(projectRoot, params.taskId, {
+        radius: params.radius,
+        depth: params.depth,
+        budget: params.budget,
+        direction: params.direction,
+        includeRelates: params.includeRelates
+      }),
+      "slice"
+    );
+  },
+  context: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskContext(projectRoot, params), "context");
+  },
+  "deps.validate": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskDepsValidate(projectRoot, params.epicId, params.scope),
+      "deps.validate"
+    );
+  },
+  "deps.tree": async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.epicId) {
+      return lafsError("E_INVALID_INPUT", "epicId is required for deps.tree", "deps.tree");
+    }
+    return wrapCoreResult(
+      await taskDepsTree(projectRoot, params.epicId, params.format),
+      "deps.tree"
+    );
+  },
+  analyze: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskAnalyze(projectRoot, params.taskId, { tierLimit: params.tierLimit }),
+      "analyze"
+    );
+  },
+  impact: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskImpact(projectRoot, params.change, params.matchLimit),
+      "impact"
+    );
+  },
+  next: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskNext(projectRoot, params), "next");
+  },
+  plan: async (_params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskPlan(projectRoot), "plan");
+  },
+  relates: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (params.mode) {
+      return wrapCoreResult(
+        await taskRelatesFind(projectRoot, params.taskId, {
+          mode: params.mode,
+          threshold: params.threshold
+        }),
+        "relates"
+      );
+    }
+    return wrapCoreResult(
+      await taskRelates(projectRoot, params.taskId, {
+        direction: params.direction,
+        type: params.type,
+        includeDependencies: params.includeDependencies
+      }),
+      "relates"
+    );
+  },
+  "complexity.estimate": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskComplexityEstimate(projectRoot, { taskId: params.taskId }),
+      "complexity.estimate"
+    );
+  },
+  history: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (params.taskId && params.ranking) {
+      return wrapCoreResult(
+        await taskRankingHistory(projectRoot, params.taskId, params.limit),
+        "history"
+      );
+    }
+    if (params.taskId) {
+      return wrapCoreResult(await taskHistory(projectRoot, params.taskId, params.limit), "history");
+    }
+    return wrapCoreResult(await taskWorkHistory(projectRoot), "history");
+  },
+  current: async (_params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskCurrentGet(projectRoot), "current");
+  },
+  "label.list": async (_params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskLabelList(projectRoot), "label.list");
+  },
+  "sync.links": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskSyncLinks(projectRoot, params), "sync.links");
+  },
+  // -------------------------------------------------------------------------
+  // Mutate ops
+  // -------------------------------------------------------------------------
+  "add-batch": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await tasksAddBatchOp(projectRoot, {
+        tasks: params.tasks ?? [],
+        defaultParent: typeof params.defaultParent === "string" ? params.defaultParent : void 0,
+        dryRun: typeof params.dryRun === "boolean" ? params.dryRun : void 0
+      }),
+      "add-batch"
+    );
+  },
+  add: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await addTaskWithSessionScope(projectRoot, {
+        ...params,
+        description: typeof params.description === "string" ? params.description : void 0
+      }),
+      "add"
+    );
+  },
+  update: async (params) => {
+    const projectRoot = getProjectRoot();
+    const { taskId, ...updates } = params;
+    return wrapCoreResult(await taskUpdate(projectRoot, taskId, updates), "update");
+  },
+  complete: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (params.force !== void 0) {
+      return lafsError(
+        "E_FLAG_REMOVED",
+        "--force has been removed. Use evidence-based `cleo verify --gate \u2026 --evidence \u2026` or set CLEO_OWNER_OVERRIDE=1 on verify for emergency bypass (audited). See ADR-051.",
+        "complete"
+      );
+    }
+    const result = await completeTaskStrict(projectRoot, params.taskId, {
+      notes: params.notes,
+      overrideReason: params.overrideReason,
+      acknowledgeRisk: params.acknowledgeRisk,
+      // T10509 — AC-coverage gate waiver path
+      waiveAc: params.waiveAc,
+      waiveReason: params.waiveReason,
+      // T10538 — cancelled-child waiver (PM-Core V2 agent-trust)
+      cancelledChildWaiverReason: params.cancelledChildWaiverReason,
+      // T11954 (DHQ-071) — depends-edge waiver for stale/over-specified deps
+      waiveDependsReason: params.waiveDependsReason,
+      // T12503 — optimistic concurrency (--if-match)
+      expectedUpdatedAt: params.expectedUpdatedAt
+    });
+    setImmediate(async () => {
+      try {
+        const { trackMemoryUsage } = await import("@cleocode/core/memory/quality-feedback");
+        await trackMemoryUsage(projectRoot, params.taskId, true, params.taskId, "success");
+      } catch {
+      }
+    });
+    return wrapCoreResult(result, "complete");
+  },
+  cancel: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskCancel(projectRoot, params.taskId, {
+        reason: params.reason,
+        children: params.children,
+        reparentTo: params.reparentTo,
+        force: params.force,
+        cascadeThreshold: params.cascadeThreshold,
+        allowCascade: params.allowCascade
+      }),
+      "cancel"
+    );
+  },
+  "reconcile-scope": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskReconcileScope(projectRoot, {
+        rootId: params.rootId,
+        apply: params.apply,
+        threshold: params.threshold
+      }),
+      "reconcile-scope"
+    );
+  },
+  decompose: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskDecompose(projectRoot, {
+        taskId: params.taskId,
+        childTitle: params.childTitle,
+        childDescription: params.childDescription,
+        dryRun: params.dryRun
+      }),
+      "decompose"
+    );
+  },
+  delete: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskDelete(projectRoot, params.taskId, params.force, params.cascade),
+      "delete"
+    );
+  },
+  archive: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskArchive(projectRoot, params.taskId, params.before, {
+        taskIds: params.taskIds,
+        includeCancelled: params.includeCancelled,
+        dryRun: params.dryRun
+      }),
+      "archive"
+    );
+  },
+  restore: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (params.from === "done") {
+      return wrapCoreResult(
+        await taskReopen(projectRoot, params.taskId, {
+          status: params.status,
+          reason: params.reason
+        }),
+        "restore"
+      );
+    }
+    if (params.from === "archived") {
+      return wrapCoreResult(
+        await taskUnarchive(projectRoot, params.taskId, {
+          status: params.status,
+          preserveStatus: params.preserveStatus
+        }),
+        "restore"
+      );
+    }
+    return wrapCoreResult(
+      await taskRestore(projectRoot, params.taskId, {
+        cascade: params.cascade,
+        notes: params.notes
+      }),
+      "restore"
+    );
+  },
+  reparent: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskReparent(projectRoot, params.taskId, params.newParentId ?? null),
+      "reparent"
+    );
+  },
+  reorder: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskReorder(projectRoot, params.taskId, params.position),
+      "reorder"
+    );
+  },
+  // T11786 (epic T11556) — within-column re-rank from an explicit ID order.
+  "reorder-rank": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskReorderRank(projectRoot, params.orderedIds ?? []),
+      "reorder-rank"
+    );
+  },
+  // T11786 (epic T11556) — atomic multi-task status/stage move.
+  "bulk-move": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskBulkMove(projectRoot, params.taskIds ?? [], {
+        status: params.status,
+        pipelineStage: params.pipelineStage
+      }),
+      "bulk-move"
+    );
+  },
+  // T11786 (epic T11556) — first-class assignee set/clear (distinct from claim).
+  assignee: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskAssignee(projectRoot, params.taskId, params.assignee),
+      "assignee"
+    );
+  },
+  "relates.add": async (params) => {
+    const projectRoot = getProjectRoot();
+    const relatedId = params.relatedId ?? params.targetId;
+    if (!relatedId) {
+      return lafsError("E_INVALID_INPUT", "relatedId (or targetId) is required", "relates.add");
+    }
+    return wrapCoreResult(
+      await taskRelatesAdd(projectRoot, params.taskId, relatedId, params.type, params.reason),
+      "relates.add"
+    );
+  },
+  "ranking.revert": async (params) => {
+    if (!params.entryId) {
+      return lafsError("E_INVALID_INPUT", "entryId is required", "ranking.revert");
+    }
+    return wrapCoreResult(
+      await taskRankingRevert(getProjectRoot(), {
+        entryId: params.entryId,
+        ...params.reason !== void 0 ? { reason: params.reason } : {},
+        ...params.force ? { force: true } : {}
+      }),
+      "ranking.revert"
+    );
+  },
+  "relates.add-batch": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskRelatesAddBatch(projectRoot, params), "relates.add-batch");
+  },
+  "relates.remove": async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.relatedId) {
+      return lafsError("E_INVALID_INPUT", "relatedId is required", "relates.remove");
+    }
+    return wrapCoreResult(
+      await taskRelatesRemove(projectRoot, params.taskId, params.relatedId, params.type),
+      "relates.remove"
+    );
+  },
+  start: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskStart(projectRoot, params.taskId, {
+        takeOver: params.takeOver === true,
+        forceClaim: params.forceClaim === true
+      }),
+      "start"
+    );
+  },
+  stop: async (_params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskStop(projectRoot), "stop");
+  },
+  "sync.reconcile": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskSyncReconcile(projectRoot, {
+        providerId: params.providerId,
+        externalTasks: params.externalTasks,
+        dryRun: params.dryRun,
+        conflictPolicy: params.conflictPolicy,
+        defaultPhase: params.defaultPhase,
+        defaultLabels: params.defaultLabels
+      }),
+      "sync.reconcile"
+    );
+  },
+  "sync.links.remove": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await taskSyncLinksRemove(projectRoot, params.providerId),
+      "sync.links.remove"
+    );
+  },
+  claim: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskClaim(projectRoot, params), "claim");
+  },
+  unclaim: async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await taskUnclaim(projectRoot, params), "unclaim");
+  }
+});
+var QUERY_OPS = /* @__PURE__ */ new Set([
+  "show",
+  "list",
+  "find",
+  "tree",
+  "blockers",
+  "depends",
+  // T11787 (epic T11556 · CRUD-parity audit) — `slice` and `context` had
+  // typed handlers but were ABSENT from this gate, so dispatch rejected them
+  // with E_UNSUPPORTED_OPERATION before reaching the handler (registered +
+  // implemented but not reachable). Adding them closes the parity gap.
+  "slice",
+  "context",
+  "deps.validate",
+  "deps.tree",
+  "analyze",
+  "impact",
+  "next",
+  "plan",
+  "relates",
+  "complexity.estimate",
+  "history",
+  "current",
+  "label.list",
+  "sync.links",
+  // Saga sub-domain (ADR-073)
+  "saga.list",
+  "saga.members",
+  "saga.rollup",
+  "req.list",
+  "req.migrate.preview"
+]);
+var MUTATE_OPS = /* @__PURE__ */ new Set([
+  "add",
+  "add-batch",
+  "update",
+  "complete",
+  "cancel",
+  "decompose",
+  "reconcile-scope",
+  "delete",
+  "archive",
+  "restore",
+  "reparent",
+  "reorder",
+  // T11786 (epic T11556) — bulk task mutate ops Studio's interactive Kanban binds to.
+  "reorder-rank",
+  "bulk-move",
+  "assignee",
+  "relates.add",
+  // T11575 — without this entry the domain mutate() gate rejects the op with
+  // E_INVALID_OPERATION even though the handler exists below. Mirrors the
+  // OperationDef registered in @cleocode/contracts operations-registry.
+  "relates.add-batch",
+  "relates.remove",
+  // T12693 (D11161) — undo one audited ranking change.
+  "ranking.revert",
+  "start",
+  "stop",
+  "sync.reconcile",
+  "sync.links.remove",
+  "claim",
+  "unclaim",
+  // Saga sub-domain (ADR-073)
+  "saga.create",
+  "saga.add",
+  // T10117 — repair an I5-violating saga (detach parentId, write groups edge).
+  "saga.repair",
+  // T10118 — repair verb for ADR-073 §1.2 I7 violations (detach saga member).
+  "saga.detach",
+  // T10121 — idempotent cron-safe auto-close repair (supersedes T10098 scope).
+  "saga.reconcile",
+  "req.add",
+  "req.migrate"
+]);
+async function sagaCreate(params) {
+  const title = typeof params.title === "string" ? params.title : "";
+  const description = typeof params.description === "string" ? params.description : void 0;
+  const acceptance = Array.isArray(params.acceptance) ? params.acceptance : void 0;
+  const dryRun = params.dryRun === true;
+  return wrapCoreResult(
+    await coreSagaCreate(getProjectRoot(), { title, description, acceptance, dryRun }),
+    "saga.create"
+  );
+}
+async function sagaAdd(params) {
+  const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
+  const epicId = typeof params.epicId === "string" ? params.epicId : "";
+  return wrapCoreResult(await coreSagaAdd(getProjectRoot(), { sagaId, epicId }), "saga.add");
+}
+async function sagaDetach(params) {
+  const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
+  const memberId = typeof params.memberId === "string" ? params.memberId : "";
+  const reason = typeof params.reason === "string" ? params.reason : void 0;
+  return wrapCoreResult(
+    await coreSagaDetach(getProjectRoot(), { sagaId, memberId, reason }),
+    "saga.detach"
+  );
+}
+async function sagaList() {
+  return wrapCoreResult(await coreSagaList(getProjectRoot()), "saga.list");
+}
+async function sagaMembers(params) {
+  const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
+  return wrapCoreResult(await coreSagaMembers(getProjectRoot(), { sagaId }), "saga.members");
+}
+async function sagaRollup(params) {
+  const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
+  return wrapCoreResult(await coreSagaRollup(getProjectRoot(), { sagaId }), "saga.rollup");
+}
+async function sagaRepair(params) {
+  const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
+  return wrapCoreResult(await coreSagaRepair(getProjectRoot(), { sagaId }), "saga.repair");
+}
+async function sagaReconcile(params) {
+  const sagaId = typeof params.sagaId === "string" && params.sagaId.length > 0 ? params.sagaId : void 0;
+  const dryRun = params.dryRun === true;
+  return wrapCoreResult(
+    await coreSagaReconcile(getProjectRoot(), { sagaId, dryRun }),
+    "saga.reconcile"
+  );
+}
+function stampSuggestedNext(response, operation, params) {
+  if (!response.success) return response;
+  const builder = TASKS_SUGGESTED_NEXT_BUILDERS[operation];
+  if (!builder) return response;
+  let suggestions;
+  try {
+    suggestions = builder(params, response.data);
+  } catch {
+    return response;
+  }
+  if (suggestions.length === 0) return response;
+  return {
+    ...response,
+    meta: {
+      ...response.meta,
+      suggestedNext: suggestions
+    }
+  };
+}
+var TasksHandler = class {
+  // -----------------------------------------------------------------------
+  // Query
+  // -----------------------------------------------------------------------
+  /**
+   * Execute a read-only tasks query operation.
+   *
+   * @param operation - The tasks query op name (e.g. 'show', 'list').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "tasks", operation, startTime);
+    }
+    if (operation === "impact" && !params?.change) {
+      return errorResult(
+        "query",
+        "tasks",
+        operation,
+        "E_INVALID_INPUT",
+        "change is required (free-text description of the proposed change)",
+        startTime
+      );
+    }
+    try {
+      if (operation === "req.list" || operation === "req.migrate.preview") {
+        if (typeof params?.taskId !== "string" || !params.taskId.trim()) {
+          return errorResult(
+            "query",
+            "tasks",
+            operation,
+            "E_INVALID_INPUT",
+            "taskId is required",
+            startTime
+          );
+        }
+        if (operation === "req.migrate.preview" && params.apply !== void 0 && params.apply !== false) {
+          return errorResult(
+            "query",
+            "tasks",
+            operation,
+            "E_INVALID_INPUT",
+            "Migration query requires apply=false; use the mutate gateway with apply=true to write",
+            startTime
+          );
+        }
+        const root = getProjectRoot();
+        const data = operation === "req.list" ? await reqList(root, params.taskId) : await reqMigrate(root, params.taskId, false);
+        return wrapResult({ success: true, data }, "query", "tasks", operation, startTime);
+      }
+      if (operation === "saga.list") {
+        const envelope = await sagaList();
+        return wrapResult(envelopeToEngineResult(envelope), "query", "tasks", operation, startTime);
+      }
+      if (operation === "saga.members") {
+        const envelope = await sagaMembers(params ?? {});
+        return wrapResult(envelopeToEngineResult(envelope), "query", "tasks", operation, startTime);
+      }
+      if (operation === "saga.rollup") {
+        const envelope = await sagaRollup(params ?? {});
+        return wrapResult(envelopeToEngineResult(envelope), "query", "tasks", operation, startTime);
+      }
+    } catch (error) {
+      getLogger("domain:tasks").error(
+        { gateway: "query", domain: "tasks", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("query", "tasks", operation, error, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _tasksTypedHandler,
+        operation,
+        params ?? {}
+      );
+      const response = wrapResult(
+        envelopeToEngineResult(envelope),
+        "query",
+        "tasks",
+        operation,
+        startTime
+      );
+      return stampSuggestedNext(response, operation, params ?? {});
+    } catch (error) {
+      getLogger("domain:tasks").error(
+        { gateway: "query", domain: "tasks", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("query", "tasks", operation, error, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Mutate
+  // -----------------------------------------------------------------------
+  /**
+   * Execute a state-modifying tasks mutation operation.
+   *
+   * @param operation - The tasks mutate op name (e.g. 'add', 'update').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "tasks", operation, startTime);
+    }
+    try {
+      if (operation === "req.add" || operation === "req.migrate") {
+        if (typeof params?.taskId !== "string" || !params.taskId.trim()) {
+          return errorResult(
+            "mutate",
+            "tasks",
+            operation,
+            "E_INVALID_INPUT",
+            "taskId is required",
+            startTime
+          );
+        }
+        if (operation === "req.add") {
+          if (typeof params.gate !== "string") {
+            return errorResult(
+              "mutate",
+              "tasks",
+              operation,
+              "E_INVALID_INPUT",
+              "gate must be AcceptanceGate JSON text; use req add --gate",
+              startTime
+            );
+          }
+          const { parseGateJson } = await import("@cleocode/core/tasks/req");
+          const gate = parseGateJson(params.gate);
+          const data2 = await reqAdd(getProjectRoot(), params.taskId, gate);
+          return wrapResult({ success: true, data: data2 }, "mutate", "tasks", operation, startTime);
+        }
+        if (params.apply !== true) {
+          return errorResult(
+            "mutate",
+            "tasks",
+            operation,
+            "E_INVALID_INPUT",
+            "Migration writes require apply=true; use the query gateway for preview",
+            startTime
+          );
+        }
+        const data = await reqMigrate(getProjectRoot(), params.taskId, true);
+        return wrapResult({ success: true, data }, "mutate", "tasks", operation, startTime);
+      }
+      if (operation === "saga.create") {
+        const envelope = await sagaCreate(params ?? {});
+        return wrapResult(
+          envelopeToEngineResult(envelope),
+          "mutate",
+          "tasks",
+          operation,
+          startTime
+        );
+      }
+      if (operation === "saga.add") {
+        const envelope = await sagaAdd(params ?? {});
+        return wrapResult(
+          envelopeToEngineResult(envelope),
+          "mutate",
+          "tasks",
+          operation,
+          startTime
+        );
+      }
+      if (operation === "saga.repair") {
+        const envelope = await sagaRepair(params ?? {});
+        return wrapResult(
+          envelopeToEngineResult(envelope),
+          "mutate",
+          "tasks",
+          operation,
+          startTime
+        );
+      }
+      if (operation === "saga.detach") {
+        const envelope = await sagaDetach(params ?? {});
+        return wrapResult(
+          envelopeToEngineResult(envelope),
+          "mutate",
+          "tasks",
+          operation,
+          startTime
+        );
+      }
+      if (operation === "saga.reconcile") {
+        const envelope = await sagaReconcile(params ?? {});
+        return wrapResult(
+          envelopeToEngineResult(envelope),
+          "mutate",
+          "tasks",
+          operation,
+          startTime
+        );
+      }
+    } catch (error) {
+      getLogger("domain:tasks").error(
+        { gateway: "mutate", domain: "tasks", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("mutate", "tasks", operation, error, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _tasksTypedHandler,
+        operation,
+        params ?? {}
+      );
+      const response = wrapResult(
+        envelopeToEngineResult(envelope),
+        "mutate",
+        "tasks",
+        operation,
+        startTime
+      );
+      return stampSuggestedNext(response, operation, params ?? {});
+    } catch (error) {
+      getLogger("domain:tasks").error(
+        { gateway: "mutate", domain: "tasks", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("mutate", "tasks", operation, error, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Supported operations
+  // -----------------------------------------------------------------------
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: [
+        "show",
+        "list",
+        "find",
+        "tree",
+        "blockers",
+        "depends",
+        // T11787 (epic T11556) — slice/context: registered + implemented; now gated-in.
+        "slice",
+        "context",
+        "deps.validate",
+        "deps.tree",
+        "analyze",
+        "impact",
+        "next",
+        "plan",
+        "relates",
+        "complexity.estimate",
+        "history",
+        "current",
+        "label.list",
+        "sync.links",
+        // Saga sub-domain (ADR-073)
+        "saga.list",
+        "saga.members",
+        "saga.rollup",
+        "req.list",
+        "req.migrate.preview"
+      ],
+      mutate: [
+        "add",
+        "update",
+        "complete",
+        "cancel",
+        "delete",
+        "archive",
+        "restore",
+        "reparent",
+        "reorder",
+        // T11786 (epic T11556) — bulk task mutate ops Studio's Kanban binds to.
+        "reorder-rank",
+        "bulk-move",
+        "assignee",
+        "relates.add",
+        "relates.remove",
+        "ranking.revert",
+        "start",
+        "stop",
+        "sync.reconcile",
+        "sync.links.remove",
+        "claim",
+        "unclaim",
+        // Saga sub-domain (ADR-073)
+        "saga.create",
+        "saga.add",
+        // T10117 — repair an I5-violating saga.
+        "saga.repair",
+        // T10118 — repair verb for ADR-073 §1.2 I7 violations
+        "saga.detach",
+        // T10121 — idempotent cron-safe auto-close repair.
+        "saga.reconcile",
+        "req.add",
+        "req.migrate"
+      ]
+    };
+  }
+};
+export {
+  TasksHandler
+};
+//# sourceMappingURL=tasks-C24KHTFF.js.map