@cleocode/contracts 2026.4.141 → 2026.4.143

package/src/operations/sentient.ts

@@ -0,0 +1,208 @@
+/**
+ * Sentient Domain Operations (10 operations)
+ *
+ * Query operations: 2 (propose.list, allowlist.list)
+ * Mutate operations: 5 (propose.accept, propose.reject, propose.run, propose.enable, propose.disable)
+ * Allowlist mutations: 2 (allowlist.add, allowlist.remove)
+ *
+ * Operations for autonomous Tier-2 proposal management and owner allowlist control.
+ * All operations emit LAFS-compliant envelopes.
+ *
+ * @task T1008 — Sentient Tier 2 Proposals
+ * @task T1421 — Sentient domain typed narrowing (Wave D · T975 follow-on)
+ */
+
+// ---------------------------------------------------------------------------
+// Query Operations
+// ---------------------------------------------------------------------------
+
+/** Parameters for `propose.list` — list all pending proposals. */
+export interface ProposeListParams {
+  /** Maximum number of proposals to return (default: 50). */
+  limit?: number;
+}
+
+/** Minimal proposal for wire format. */
+export interface Proposal {
+  /** Task ID of the proposal. */
+  id: string;
+  /** Task title. */
+  title: string;
+  /** Task description. */
+  description: string;
+  /** Task status (always 'proposed' when returned). */
+  status: string;
+  /** Task priority. */
+  priority?: string;
+  /** Labels attached to the task. */
+  labels: string[];
+  /** ISO timestamp when the proposal was created. */
+  createdAt: string;
+  /** Proposal metadata (weight, reasoning, etc). */
+  meta?: Record<string, unknown> | null;
+}
+
+/** Result of `propose.list`. */
+export interface ProposeListResult {
+  /** Array of proposals, sorted by weight descending. */
+  proposals: Proposal[];
+  /** Total count of proposals returned. */
+  total: number;
+}
+
+// propose.diff
+/** Parameters for `propose.diff` — show what a proposal would change. */
+export interface ProposeDiffParams {
+  /** Proposal task ID. */
+  id: string;
+}
+
+/** Result of `propose.diff` — Tier-3 stub. */
+export interface ProposeDiffResult {
+  /** Proposal ID. */
+  id: string;
+  /** Content diff (null in Tier-2; Tier-3 feature). */
+  diff: null;
+  /** Explanation message. */
+  message: string;
+}
+
+// allowlist.list
+/** Parameters for `allowlist.list` — no params required. */
+export type AllowlistListParams = Record<string, never>;
+
+/** Result of `allowlist.list`. */
+export interface AllowlistListResult {
+  /** Array of base64-encoded owner public keys. */
+  ownerPubkeys: string[];
+  /** Total count of pubkeys in the allowlist. */
+  count: number;
+}
+
+// ---------------------------------------------------------------------------
+// Mutate Operations
+// ---------------------------------------------------------------------------
+
+// propose.accept
+/** Parameters for `propose.accept` — accept a proposal. */
+export interface ProposeAcceptParams {
+  /** Proposal task ID to accept. */
+  id: string;
+}
+
+/** Result of `propose.accept`. */
+export interface ProposeAcceptResult {
+  /** Task ID that was accepted. */
+  id: string;
+  /** New task status ('pending'). */
+  status: string;
+  /** ISO timestamp when accepted. */
+  acceptedAt: string;
+}
+
+// propose.reject
+/** Parameters for `propose.reject` — reject a proposal. */
+export interface ProposeRejectParams {
+  /** Proposal task ID to reject. */
+  id: string;
+  /** Reason for rejection. */
+  reason?: string;
+}
+
+/** Result of `propose.reject`. */
+export interface ProposeRejectResult {
+  /** Task ID that was rejected. */
+  id: string;
+  /** New task status ('cancelled'). */
+  status: string;
+  /** ISO timestamp when rejected. */
+  rejectedAt: string;
+  /** Rejection reason. */
+  reason: string;
+}
+
+// propose.run
+/** Parameters for `propose.run` — manually trigger a propose tick. */
+export type ProposeRunParams = Record<string, never>;
+
+/** Result of `propose.run`. */
+export interface ProposeRunResult {
+  /** Outcome from the propose tick. */
+  outcome: unknown;
+}
+
+// propose.enable
+/** Parameters for `propose.enable` — enable Tier-2 proposals. */
+export type ProposeEnableParams = Record<string, never>;
+
+/** Result of `propose.enable`. */
+export interface ProposeEnableResult {
+  /** Whether Tier-2 is now enabled. */
+  tier2Enabled: boolean;
+  /** Confirmation message. */
+  message: string;
+}
+
+// propose.disable
+/** Parameters for `propose.disable` — disable Tier-2 proposals. */
+export type ProposeDisableParams = Record<string, never>;
+
+/** Result of `propose.disable`. */
+export interface ProposeDisableResult {
+  /** Whether Tier-2 is now enabled (false after disable). */
+  tier2Enabled: boolean;
+  /** Confirmation message. */
+  message: string;
+}
+
+// allowlist.add
+/** Parameters for `allowlist.add` — add a pubkey to the allowlist. */
+export interface AllowlistAddParams {
+  /** Base64-encoded public key to add. */
+  pubkey: string;
+}
+
+/** Result of `allowlist.add`. */
+export interface AllowlistAddResult {
+  /** The pubkey that was added. */
+  added: string;
+}
+
+// allowlist.remove
+/** Parameters for `allowlist.remove` — remove a pubkey from the allowlist. */
+export interface AllowlistRemoveParams {
+  /** Base64-encoded public key to remove. */
+  pubkey: string;
+}
+
+/** Result of `allowlist.remove`. */
+export interface AllowlistRemoveResult {
+  /** The pubkey that was removed. */
+  removed: string;
+}
+
+// ---------------------------------------------------------------------------
+// Typed operation record (Wave D adapter — T975 follow-on)
+// ---------------------------------------------------------------------------
+
+/**
+ * Typed operation record for the sentient domain.
+ *
+ * Maps each operation name (as dispatched by the registry — no domain prefix)
+ * to its `[Params, Result]` tuple. Used by `TypedDomainHandler<SentientOps>`
+ * in the dispatch layer to provide compile-time narrowing of params.
+ *
+ * @task T1421 — Sentient domain typed narrowing (Wave D follow-on)
+ */
+export type SentientOps = {
+  readonly 'propose.list': readonly [ProposeListParams, ProposeListResult];
+  readonly 'propose.diff': readonly [ProposeDiffParams, ProposeDiffResult];
+  readonly 'propose.accept': readonly [ProposeAcceptParams, ProposeAcceptResult];
+  readonly 'propose.reject': readonly [ProposeRejectParams, ProposeRejectResult];
+  readonly 'propose.run': readonly [ProposeRunParams, ProposeRunResult];
+  readonly 'propose.enable': readonly [ProposeEnableParams, ProposeEnableResult];
+  readonly 'propose.disable': readonly [ProposeDisableParams, ProposeDisableResult];
+  readonly 'allowlist.list': readonly [AllowlistListParams, AllowlistListResult];
+  readonly 'allowlist.add': readonly [AllowlistAddParams, AllowlistAddResult];
+  readonly 'allowlist.remove': readonly [AllowlistRemoveParams, AllowlistRemoveResult];
+};

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];
+};