@cleocode/contracts 2026.4.141 → 2026.4.142

package/src/operations/tasks.ts

@@ -103,6 +103,12 @@ export interface TasksFindParams {
   fields?: string;
   /** When true, emit verbose per-match diagnostic fields. @task T963 */
   verbose?: boolean;
+  /**
+   * Filter by role axis (T944 — orthogonal axes).
+   * Accepts the same values as the `role` field on TasksCreateParams.
+   * @task T963 / T944
+   */
+  role?: string;
 }
 export type TasksFindResult = MinimalTask[];
 
@@ -416,3 +422,304 @@ export interface TasksCurrentResult {
   since?: string;
   sessionId?: string;
 }
+
+// tasks.show (with optional history/ivtrHistory flags)
+export interface TasksShowParams {
+  taskId: string;
+  /** When true, include task change history. */
+  history?: boolean;
+  /** When true, include IVTR phase history. */
+  ivtrHistory?: boolean;
+}
+export type TasksShowResult = unknown;
+
+// tasks.tree dispatch params (with optional withBlockers flag — dispatch alias)
+export interface TasksTreeDispatchParams {
+  taskId?: string;
+  withBlockers?: boolean;
+}
+export type TasksTreeDispatchResult = unknown;
+
+// tasks.blockers dispatch params (with optional analyze/limit)
+export interface TasksBlockersQueryParams {
+  analyze?: boolean;
+  limit?: number;
+}
+export type TasksBlockersQueryResult = unknown;
+
+// tasks.depends (with action routing for overview/cycles)
+export interface TasksDependsParams {
+  taskId?: string;
+  direction?: 'upstream' | 'downstream' | 'both';
+  tree?: boolean;
+  action?: 'overview' | 'cycles';
+}
+export type TasksDependsResult = unknown;
+
+// tasks.analyze dispatch params (with optional taskId and tierLimit)
+export interface TasksAnalyzeQueryParams {
+  taskId?: string;
+  tierLimit?: number;
+}
+export type TasksAnalyzeQueryResult = unknown;
+
+// tasks.impact
+export interface TasksImpactParams {
+  change: string;
+  matchLimit?: number;
+}
+export type TasksImpactResult = unknown;
+
+// tasks.next dispatch params (with count and explain)
+export interface TasksNextQueryParams {
+  count?: number;
+  explain?: boolean;
+}
+export type TasksNextQueryResult = unknown;
+
+// tasks.plan
+export type TasksPlanParams = Record<string, never>;
+export type TasksPlanResult = unknown;
+
+// tasks.relates (with mode routing for suggest/discover)
+export interface TasksRelatesParams {
+  taskId: string;
+  mode?: 'suggest' | 'discover';
+  threshold?: number;
+}
+export type TasksRelatesResult = unknown;
+
+// tasks.complexity.estimate
+export interface TasksComplexityEstimateParams {
+  taskId: string;
+}
+export type TasksComplexityEstimateResult = unknown;
+
+// tasks.history
+export interface TasksHistoryParams {
+  taskId?: string;
+  limit?: number;
+}
+export type TasksHistoryResult = unknown;
+
+// tasks.label.list
+export type TasksLabelListParams = Record<string, never>;
+export type TasksLabelListResult = unknown;
+
+// tasks.sync.links
+export interface TasksSyncLinksParams {
+  providerId?: string;
+  taskId?: string;
+}
+export type TasksSyncLinksResult = unknown;
+
+// tasks.sync.reconcile
+export interface TasksSyncReconcileParams {
+  providerId: string;
+  externalTasks: import('../task-sync.js').ExternalTask[];
+  dryRun?: boolean;
+  conflictPolicy?: string;
+  defaultPhase?: string;
+  defaultLabels?: string[];
+}
+export type TasksSyncReconcileResult = unknown;
+
+// tasks.sync.links.remove
+export interface TasksSyncLinksRemoveParams {
+  providerId: string;
+}
+export type TasksSyncLinksRemoveResult = unknown;
+
+// tasks.cancel
+export interface TasksCancelParams {
+  taskId: string;
+  reason?: string;
+}
+export type TasksCancelResult = unknown;
+
+// tasks.restore (with from routing: done → reopen, archived → unarchive)
+export interface TasksRestoreParams {
+  taskId: string;
+  from?: 'done' | 'archived';
+  status?: string;
+  reason?: string;
+  preserveStatus?: boolean;
+  cascade?: boolean;
+  notes?: string;
+}
+export type TasksRestoreResult = unknown;
+
+// tasks.reparent (dispatch-level params include newParentId)
+export interface TasksReparentQueryParams {
+  taskId: string;
+  /** New parent ID, or null/undefined to promote to root. */
+  newParentId: string | null | undefined;
+}
+export type TasksReparentDispatchResult = unknown;
+
+// tasks.reorder (dispatch-level params)
+export interface TasksReorderQueryParams {
+  taskId: string;
+  position: number;
+}
+export type TasksReorderDispatchResult = unknown;
+
+// tasks.relates.add (accepts both relatedId and targetId aliases)
+export interface TasksRelatesAddParams {
+  taskId: string;
+  relatedId?: string;
+  targetId?: string;
+  type: string;
+  reason?: string;
+}
+export type TasksRelatesAddResult = unknown;
+
+// tasks.add (dispatch-level alias params — extends TasksCreateParams)
+export interface TasksAddParams {
+  title: string;
+  description?: string;
+  parent?: string;
+  parentId?: string;
+  depends?: string[];
+  priority?: string;
+  labels?: string[];
+  type?: string;
+  acceptance?: string[];
+  phase?: string;
+  size?: string;
+  notes?: string;
+  files?: string[];
+  dryRun?: boolean;
+  parentSearch?: string;
+  role?: string;
+  kind?: string;
+  scope?: string;
+  severity?: string;
+}
+export type TasksAddResult = unknown;
+
+// tasks.update (dispatch-level alias params — extends TasksUpdateParams)
+export interface TasksUpdateQueryParams {
+  taskId: string;
+  title?: string;
+  description?: string;
+  status?: string;
+  priority?: string;
+  notes?: string;
+  note?: string;
+  labels?: string[];
+  addLabels?: string[];
+  removeLabels?: string[];
+  depends?: string[];
+  addDepends?: string[];
+  removeDepends?: string[];
+  acceptance?: string[];
+  parent?: string | null;
+  parentId?: string | null;
+  type?: string;
+  size?: string;
+  files?: string[];
+  pipelineStage?: string;
+}
+export type TasksUpdateQueryResult = unknown;
+
+// tasks.complete (dispatch-level params)
+export interface TasksCompleteQueryParams {
+  taskId: string;
+  notes?: string;
+  force?: unknown;
+}
+export type TasksCompleteQueryResult = unknown;
+
+// tasks.delete (dispatch-level params)
+export interface TasksDeleteQueryParams {
+  taskId: string;
+  force?: boolean;
+}
+export type TasksDeleteQueryResult = unknown;
+
+// tasks.archive (dispatch-level params)
+export interface TasksArchiveQueryParams {
+  taskId?: string;
+  before?: string;
+  taskIds?: string[];
+  includeCancelled?: boolean;
+  dryRun?: boolean;
+}
+export type TasksArchiveQueryResult = unknown;
+
+// tasks.claim
+export interface TasksClaimParams {
+  taskId: string;
+  agentId: string;
+}
+export type TasksClaimResult = unknown;
+
+// tasks.unclaim
+export interface TasksUnclaimParams {
+  taskId: string;
+}
+export type TasksUnclaimResult = unknown;
+
+// tasks.start (dispatch-level)
+export interface TasksStartQueryParams {
+  taskId: string;
+}
+export type TasksStartQueryResult = unknown;
+
+// tasks.stop (dispatch-level)
+export type TasksStopQueryParams = Record<string, never>;
+export type TasksStopQueryResult = unknown;
+
+// ---------------------------------------------------------------------------
+// Typed operation record (Wave D adapter — T1425)
+// ---------------------------------------------------------------------------
+
+/**
+ * Typed operation record for the tasks domain.
+ *
+ * Maps each operation name (as dispatched by the registry — no domain prefix)
+ * to its `[Params, Result]` tuple. Used by `TypedDomainHandler<TasksOps>`
+ * in the dispatch layer to provide compile-time narrowing of params.
+ *
+ * @task T1425 — tasks typed-dispatch migration
+ */
+export type TasksOps = {
+  // Query ops
+  readonly show: readonly [TasksShowParams, TasksShowResult];
+  readonly list: readonly [TasksListParams, TasksListResult];
+  readonly find: readonly [TasksFindParams, TasksFindResult];
+  readonly tree: readonly [TasksTreeDispatchParams, TasksTreeDispatchResult];
+  readonly blockers: readonly [TasksBlockersQueryParams, TasksBlockersQueryResult];
+  readonly depends: readonly [TasksDependsParams, TasksDependsResult];
+  readonly analyze: readonly [TasksAnalyzeQueryParams, TasksAnalyzeQueryResult];
+  readonly impact: readonly [TasksImpactParams, TasksImpactResult];
+  readonly next: readonly [TasksNextQueryParams, TasksNextQueryResult];
+  readonly plan: readonly [TasksPlanParams, TasksPlanResult];
+  readonly relates: readonly [TasksRelatesParams, TasksRelatesResult];
+  readonly 'complexity.estimate': readonly [
+    TasksComplexityEstimateParams,
+    TasksComplexityEstimateResult,
+  ];
+  readonly history: readonly [TasksHistoryParams, TasksHistoryResult];
+  readonly current: readonly [TasksCurrentParams, TasksCurrentResult];
+  readonly 'label.list': readonly [TasksLabelListParams, TasksLabelListResult];
+  readonly 'sync.links': readonly [TasksSyncLinksParams, TasksSyncLinksResult];
+  // Mutate ops
+  readonly add: readonly [TasksAddParams, TasksAddResult];
+  readonly update: readonly [TasksUpdateQueryParams, TasksUpdateQueryResult];
+  readonly complete: readonly [TasksCompleteQueryParams, TasksCompleteQueryResult];
+  readonly cancel: readonly [TasksCancelParams, TasksCancelResult];
+  readonly delete: readonly [TasksDeleteQueryParams, TasksDeleteQueryResult];
+  readonly archive: readonly [TasksArchiveQueryParams, TasksArchiveQueryResult];
+  readonly restore: readonly [TasksRestoreParams, TasksRestoreResult];
+  readonly reparent: readonly [TasksReparentQueryParams, TasksReparentDispatchResult];
+  readonly reorder: readonly [TasksReorderQueryParams, TasksReorderDispatchResult];
+  readonly 'relates.add': readonly [TasksRelatesAddParams, TasksRelatesAddResult];
+  readonly start: readonly [TasksStartQueryParams, TasksStartQueryResult];
+  readonly stop: readonly [TasksStopQueryParams, TasksStopQueryResult];
+  readonly 'sync.reconcile': readonly [TasksSyncReconcileParams, TasksSyncReconcileResult];
+  readonly 'sync.links.remove': readonly [TasksSyncLinksRemoveParams, TasksSyncLinksRemoveResult];
+  readonly claim: readonly [TasksClaimParams, TasksClaimResult];
+  readonly unclaim: readonly [TasksUnclaimParams, TasksUnclaimResult];
+};

package/src/operations/validate.ts

@@ -303,3 +303,49 @@ export interface ValidateComplianceSyncParams {
   force?: boolean;
 }
 export type ValidateComplianceSyncResult = Record<string, unknown>;
+
+// ---------------------------------------------------------------------------
+// Typed operation record (Wave D adapter — T975)
+// ---------------------------------------------------------------------------
+
+/**
+ * Typed operation record for the check domain.
+ *
+ * Maps each operation name (as dispatched by the registry — no domain prefix)
+ * to its `[Params, Result]` tuple. Used by `TypedDomainHandler<CheckOps>`
+ * in the dispatch layer to provide compile-time narrowing of params.
+ *
+ * @task T1423 — check typed narrowing (T975 follow-on)
+ */
+export type CheckOps = {
+  readonly schema: readonly [ValidateSchemaParams, ValidateSchemaResult];
+  readonly task: readonly [ValidateTaskParams, ValidateTaskResult];
+  readonly manifest: readonly [ValidateManifestParams, ValidateManifestResult];
+  readonly output: readonly [ValidateOutputParams, ValidateOutputResult];
+  readonly 'compliance.summary': readonly [
+    ValidateComplianceSummaryParams,
+    ValidateComplianceSummaryResult,
+  ];
+  readonly 'compliance.record': readonly [
+    ValidateComplianceRecordParams,
+    ValidateComplianceRecordResult,
+  ];
+  readonly 'compliance.sync': readonly [ValidateComplianceSyncParams, ValidateComplianceSyncResult];
+  readonly test: readonly [ValidateTestStatusParams, ValidateTestStatusResult];
+  readonly 'test.run': readonly [ValidateTestRunParams, ValidateTestRunResult];
+  readonly 'test.coverage': readonly [ValidateTestCoverageParams, ValidateTestCoverageResult];
+  readonly coherence: readonly [ValidateCoherenceParams, ValidateCoherenceResult];
+  readonly 'gate.status': readonly [ValidateGateParams, ValidateGateResult];
+  readonly 'gate.set': readonly [ValidateGateParams, ValidateGateResult];
+  readonly 'verify.explain': readonly [ValidateVerifyExplainParams, ValidateVerifyExplainResult];
+  readonly 'archive.stats': readonly [ValidateArchiveStatsParams, ValidateArchiveStatsResult];
+  readonly 'chain.validate': readonly [ValidateChainParams, ValidateChainResult];
+  readonly grade: readonly [ValidateGradeParams, ValidateGradeResult];
+  readonly 'grade.list': readonly [ValidateGradeListParams, ValidateGradeListResult];
+  readonly canon: readonly [ValidateCanonParams, ValidateCanonResult];
+  readonly 'workflow.compliance': readonly [
+    ValidateWorkflowComplianceParams,
+    ValidateWorkflowComplianceResult,
+  ];
+  readonly protocol: readonly [ValidateProtocolParams, ValidateProtocolResult];
+};