@cleocode/contracts 2.0.0

package/src/operations/lifecycle.ts

@@ -0,0 +1,176 @@
+/**
+ * Lifecycle Domain Operations (10 operations)
+ *
+ * Query operations: 5
+ * Mutate operations: 5
+ */
+
+import type { StageStatus } from '../status-registry.js';
+export type { StageStatus };
+
+/**
+ * Common lifecycle types
+ */
+export type LifecycleStage =
+  | 'research'
+  | 'consensus'
+  | 'architecture_decision'
+  | 'specification'
+  | 'decomposition'
+  | 'implementation'
+  | 'validation'
+  | 'testing'
+  | 'release';
+
+export type GateStatus = 'passed' | 'failed' | 'blocked' | null;
+
+export interface StageRecord {
+  stage: LifecycleStage;
+  status: StageStatus;
+  started?: string;
+  completed?: string;
+  agent?: string;
+  notes?: string;
+}
+
+export interface Gate {
+  name: string;
+  stage: LifecycleStage;
+  status: GateStatus;
+  agent?: string;
+  timestamp?: string;
+  reason?: string;
+}
+
+/**
+ * Query Operations
+ */
+
+// lifecycle.check
+export interface LifecycleCheckParams {
+  taskId: string;
+  targetStage: LifecycleStage;
+}
+export interface LifecycleCheckResult {
+  taskId: string;
+  targetStage: LifecycleStage;
+  canProceed: boolean;
+  missingPrerequisites: LifecycleStage[];
+  gateStatus: 'passed' | 'failed' | 'pending';
+}
+
+// lifecycle.status
+export interface LifecycleStatusParams {
+  taskId?: string;
+  epicId?: string;
+}
+export interface LifecycleStatusResult {
+  id: string;
+  currentStage: LifecycleStage;
+  stages: StageRecord[];
+  completedStages: LifecycleStage[];
+  pendingStages: LifecycleStage[];
+}
+
+// lifecycle.history
+export interface LifecycleHistoryParams {
+  taskId: string;
+}
+export interface LifecycleHistoryEntry {
+  stage: LifecycleStage;
+  from: StageStatus;
+  to: StageStatus;
+  timestamp: string;
+  agent?: string;
+  notes?: string;
+}
+export type LifecycleHistoryResult = LifecycleHistoryEntry[];
+
+// lifecycle.gates
+export interface LifecycleGatesParams {
+  taskId: string;
+}
+export type LifecycleGatesResult = Gate[];
+
+// lifecycle.prerequisites
+export interface LifecyclePrerequisitesParams {
+  targetStage: LifecycleStage;
+}
+export interface LifecyclePrerequisitesResult {
+  targetStage: LifecycleStage;
+  prerequisites: LifecycleStage[];
+  optional: LifecycleStage[];
+}
+
+/**
+ * Mutate Operations
+ */
+
+// lifecycle.progress
+export interface LifecycleProgressParams {
+  taskId: string;
+  stage: LifecycleStage;
+  status: StageStatus;
+  notes?: string;
+}
+export interface LifecycleProgressResult {
+  taskId: string;
+  stage: LifecycleStage;
+  status: StageStatus;
+  timestamp: string;
+}
+
+// lifecycle.skip
+export interface LifecycleSkipParams {
+  taskId: string;
+  stage: LifecycleStage;
+  reason: string;
+}
+export interface LifecycleSkipResult {
+  taskId: string;
+  stage: LifecycleStage;
+  skipped: string;
+  reason: string;
+}
+
+// lifecycle.reset
+export interface LifecycleResetParams {
+  taskId: string;
+  stage: LifecycleStage;
+  reason: string;
+}
+export interface LifecycleResetResult {
+  taskId: string;
+  stage: LifecycleStage;
+  reset: string;
+  reason: string;
+  warning: string;
+}
+
+// lifecycle.gate.pass
+export interface LifecycleGatePassParams {
+  taskId: string;
+  gateName: string;
+  agent: string;
+  notes?: string;
+}
+export interface LifecycleGatePassResult {
+  taskId: string;
+  gateName: string;
+  status: 'passed';
+  timestamp: string;
+}
+
+// lifecycle.gate.fail
+export interface LifecycleGateFailParams {
+  taskId: string;
+  gateName: string;
+  reason: string;
+}
+export interface LifecycleGateFailResult {
+  taskId: string;
+  gateName: string;
+  status: 'failed';
+  reason: string;
+  timestamp: string;
+}

package/src/operations/orchestrate.ts

@@ -0,0 +1,199 @@
+/**
+ * Orchestrate Domain Operations (13 operations)
+ *
+ * Query operations: 7
+ * Mutate operations: 6
+ */
+
+/**
+ * Common orchestration types
+ */
+export interface Wave {
+  wave: number;
+  taskIds: string[];
+  canRunParallel: boolean;
+  dependencies: string[];
+}
+
+export interface SkillDefinition {
+  name: string;
+  description: string;
+  tags: string[];
+  model?: string;
+  protocols: string[];
+}
+
+/**
+ * Query Operations
+ */
+
+// orchestrate.status
+export interface OrchestrateStatusParams {
+  epicId: string;
+}
+export interface OrchestrateStatusResult {
+  epicId: string;
+  totalTasks: number;
+  completedTasks: number;
+  pendingTasks: number;
+  blockedTasks: number;
+  currentWave: number;
+  totalWaves: number;
+  parallelCapacity: number;
+}
+
+// orchestrate.next
+export interface OrchestrateNextParams {
+  epicId: string;
+}
+export interface OrchestrateNextResult {
+  taskId: string;
+  title: string;
+  recommendedSkill: string;
+  reasoning: string;
+}
+
+// orchestrate.ready
+export interface OrchestrateReadyParams {
+  epicId: string;
+}
+export interface OrchestrateReadyResult {
+  wave: number;
+  taskIds: string[];
+  parallelSafe: boolean;
+}
+
+// orchestrate.analyze
+export interface OrchestrateAnalyzeParams {
+  epicId: string;
+}
+export interface OrchestrateAnalyzeResult {
+  waves: Wave[];
+  criticalPath: string[];
+  estimatedParallelism: number;
+  bottlenecks: string[];
+}
+
+// orchestrate.context
+export interface OrchestrateContextParams {
+  tokens?: number;
+}
+export interface OrchestrateContextResult {
+  currentTokens: number;
+  maxTokens: number;
+  percentUsed: number;
+  level: 'safe' | 'medium' | 'high' | 'critical';
+  recommendation: string;
+}
+
+// orchestrate.waves
+export interface OrchestrateWavesParams {
+  epicId: string;
+}
+export type OrchestrateWavesResult = Wave[];
+
+// orchestrate.skill.list
+export interface OrchestrateSkillListParams {
+  filter?: string;
+}
+export type OrchestrateSkillListResult = SkillDefinition[];
+
+// orchestrate.bootstrap
+export interface OrchestrateBootstrapParams {
+  speed?: 'fast' | 'full' | 'complete';
+}
+export interface BrainState {
+  session?: { id: string; name: string; status: string; startedAt: string };
+  currentTask?: { id: string; title: string; status: string };
+  nextSuggestion?: { id: string; title: string; score: number };
+  recentDecisions?: Array<{ id: string; decision: string; timestamp: string }>;
+  blockers?: Array<{ taskId: string; title: string; blockedBy: string[] }>;
+  progress?: { total: number; done: number; active: number; blocked: number; pending: number };
+  contextDrift?: { score: number; factors: string[] };
+  _meta: { speed: 'fast' | 'full' | 'complete'; generatedAt: string; version: string };
+}
+
+/**
+ * Mutate Operations
+ */
+
+// orchestrate.startup
+export interface OrchestrateStartupParams {
+  epicId: string;
+}
+export interface OrchestrateStartupResult {
+  epicId: string;
+  status: OrchestrateStatusResult;
+  analysis: OrchestrateAnalyzeResult;
+  firstTask: OrchestrateNextResult;
+}
+
+// orchestrate.spawn
+export interface OrchestrateSpawnParams {
+  taskId: string;
+  skill?: string;
+  model?: string;
+}
+export interface OrchestrateSpawnResult {
+  taskId: string;
+  skill: string;
+  model: string;
+  prompt: string;
+  metadata: {
+    tokensUsed: number;
+    protocolsInjected: string[];
+    dependencies: string[];
+  };
+}
+
+// orchestrate.handoff
+export interface OrchestrateHandoffParams {
+  taskId: string;
+  protocolType: string;
+  note?: string;
+  nextAction?: string;
+  variant?: string;
+  tier?: 0 | 1 | 2;
+  idempotencyKey?: string;
+}
+export interface OrchestrateHandoffResult {
+  taskId: string;
+  predecessorSessionId: string;
+  endedSessionId: string;
+  protocolType: string;
+}
+
+// orchestrate.validate
+export interface OrchestrateValidateParams {
+  taskId: string;
+}
+export interface OrchestrateValidateResult {
+  taskId: string;
+  ready: boolean;
+  blockers: string[];
+  lifecycleGate: 'passed' | 'failed' | 'pending';
+  recommendations: string[];
+}
+
+// orchestrate.parallel.start
+export interface OrchestrateParallelStartParams {
+  epicId: string;
+  wave: number;
+}
+export interface OrchestrateParallelStartResult {
+  wave: number;
+  taskIds: string[];
+  started: string;
+}
+
+// orchestrate.parallel.end
+export interface OrchestrateParallelEndParams {
+  epicId: string;
+  wave: number;
+}
+export interface OrchestrateParallelEndResult {
+  wave: number;
+  completed: number;
+  failed: number;
+  duration: string;
+}

package/src/operations/release.ts

@@ -0,0 +1,114 @@
+/**
+ * Release Domain Operations (7 operations)
+ *
+ * All mutate operations
+ */
+
+/**
+ * Common release types
+ */
+export type ReleaseType = 'major' | 'minor' | 'patch';
+
+export interface ReleaseGate {
+  name: string;
+  description: string;
+  passed: boolean;
+  reason?: string;
+}
+
+export interface ChangelogSection {
+  type: 'feat' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore';
+  entries: Array<{
+    taskId: string;
+    message: string;
+  }>;
+}
+
+/**
+ * Mutate Operations
+ */
+
+// release.prepare
+export interface ReleasePrepareParams {
+  version: string;
+  type: ReleaseType;
+}
+export interface ReleasePrepareResult {
+  version: string;
+  type: ReleaseType;
+  currentVersion: string;
+  files: string[];
+  ready: boolean;
+  warnings: string[];
+}
+
+// release.changelog
+export interface ReleaseChangelogParams {
+  version: string;
+  sections?: Array<'feat' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore'>;
+}
+export interface ReleaseChangelogResult {
+  version: string;
+  content: string;
+  sections: ChangelogSection[];
+  commitCount: number;
+}
+
+// release.commit
+export interface ReleaseCommitParams {
+  version: string;
+  files?: string[];
+}
+export interface ReleaseCommitResult {
+  version: string;
+  commitHash: string;
+  message: string;
+  filesCommitted: string[];
+}
+
+// release.tag
+export interface ReleaseTagParams {
+  version: string;
+  message?: string;
+}
+export interface ReleaseTagResult {
+  version: string;
+  tagName: string;
+  created: string;
+}
+
+// release.push
+export interface ReleasePushParams {
+  version: string;
+  remote?: string;
+}
+export interface ReleasePushResult {
+  version: string;
+  remote: string;
+  pushed: string;
+  tagsPushed: string[];
+}
+
+// release.gates.run
+export interface ReleaseGatesRunParams {
+  gates?: string[];
+}
+export interface ReleaseGatesRunResult {
+  total: number;
+  passed: number;
+  failed: number;
+  gates: ReleaseGate[];
+  canRelease: boolean;
+}
+
+// release.rollback
+export interface ReleaseRollbackParams {
+  version: string;
+  reason: string;
+}
+export interface ReleaseRollbackResult {
+  version: string;
+  rolledBack: string;
+  restoredVersion: string;
+  reason: string;
+}

package/src/operations/research.ts

@@ -0,0 +1,156 @@
+/**
+ * Research Domain Operations (legacy alias for memory domain)
+ *
+ * Query operations: 12 (derived from memory domain)
+ * Mutate operations: 5 (derived from memory domain)
+ *
+ * Note: manifest.* operations moved to pipeline domain (T5241).
+ * inject operation moved to session.context.inject (T5241).
+ */
+
+/**
+ * Common research types
+ */
+export interface ResearchEntry {
+  id: string;
+  taskId: string;
+  title: string;
+  file: string;
+  date: string;
+  status: 'completed' | 'partial' | 'blocked';
+  agentType: string;
+  topics: string[];
+  keyFindings: string[];
+  actionable: boolean;
+  needsFollowup: string[];
+  linkedTasks: string[];
+  confidence?: number;
+}
+
+export interface ManifestEntry {
+  id: string;
+  file: string;
+  title: string;
+  date: string;
+  status: 'completed' | 'partial' | 'blocked';
+  agent_type: string;
+  topics: string[];
+  key_findings: string[];
+  actionable: boolean;
+  needs_followup: string[];
+  linked_tasks: string[];
+}
+
+/**
+ * Query Operations
+ */
+
+// research.show
+export interface ResearchShowParams {
+  researchId: string;
+}
+export type ResearchShowResult = ResearchEntry;
+
+// research.list
+export interface ResearchListParams {
+  epicId?: string;
+  status?: 'completed' | 'partial' | 'blocked';
+}
+export type ResearchListResult = ResearchEntry[];
+
+// research.query
+export interface ResearchQueryParams {
+  query: string;
+  confidence?: number;
+}
+export interface ResearchQueryResult {
+  entries: ResearchEntry[];
+  matchCount: number;
+  avgConfidence: number;
+}
+
+// research.pending
+export interface ResearchPendingParams {
+  epicId?: string;
+}
+export type ResearchPendingResult = ResearchEntry[];
+
+// research.stats
+export interface ResearchStatsParams {
+  epicId?: string;
+}
+export interface ResearchStatsResult {
+  total: number;
+  complete: number;
+  partial: number;
+  blocked: number;
+  byAgentType: Record<string, number>;
+  byTopic: Record<string, number>;
+  avgConfidence: number;
+}
+
+// pipeline.manifest.list (was research.manifest.read, moved to pipeline T5241)
+export interface ResearchManifestReadParams {
+  filter?: string;
+  limit?: number;
+  offset?: number;
+}
+export type ResearchManifestReadResult = ManifestEntry[];
+
+/**
+ * Mutate Operations
+ */
+
+// session.context.inject (was research.inject, moved to session domain T5241)
+export interface ResearchInjectParams {
+  protocolType:
+    | 'research'
+    | 'consensus'
+    | 'specification'
+    | 'decomposition'
+    | 'implementation'
+    | 'contribution'
+    | 'release';
+  taskId?: string;
+  variant?: string;
+}
+export interface ResearchInjectResult {
+  protocol: string;
+  content: string;
+  tokensUsed: number;
+}
+
+// research.link
+export interface ResearchLinkParams {
+  researchId: string;
+  taskId: string;
+  relationship?: 'supports' | 'blocks' | 'references' | 'supersedes';
+}
+export interface ResearchLinkResult {
+  researchId: string;
+  taskId: string;
+  relationship: string;
+  linked: string;
+}
+
+// pipeline.manifest.append (was research.manifest.append, moved to pipeline T5241)
+export interface ResearchManifestAppendParams {
+  entry: ManifestEntry;
+  validateFile?: boolean;
+}
+export interface ResearchManifestAppendResult {
+  id: string;
+  appended: string;
+  validated: boolean;
+}
+
+// pipeline.manifest.archive (was research.manifest.archive, moved to pipeline T5241)
+export interface ResearchManifestArchiveParams {
+  beforeDate?: string;
+  moveFiles?: boolean;
+}
+export interface ResearchManifestArchiveResult {
+  archived: number;
+  entryIds: string[];
+  filesMovedCount?: number;
+}