@cleocode/core 2026.4.5 → 2026.4.6

package/src/validation/protocols/consensus.ts

@@ -1,92 +1,62 @@
 /**
- * Consensus protocol validation.
+ * Consensus protocol — thin wrapper delegating to the canonical pure validator.
+ *
+ * The actual rules live in `../../orchestration/protocol-validators.ts`. This
+ * file exists so the CLI / dispatch layer can validate a task by ID (loading
+ * the manifest entry) without duplicating logic.
+ *
  * @task T4537
- * @epic T4454
+ * @task T260
  */
 
 import { existsSync, readFileSync } from 'node:fs';
-import { ExitCode } from '@cleocode/contracts';
-import { CleoError } from '../../errors.js';
-import { getManifestPath } from '../../paths.js';
-
-interface ValidationResult {
-  valid: boolean;
-  violations: Array<{ code: string; severity: string; message: string }>;
-  score: number;
-  protocol: string;
-  taskId: string;
-}
-
-function findManifestEntry(taskId: string, manifestPath: string): string | null {
-  if (!existsSync(manifestPath)) return null;
-  const lines = readFileSync(manifestPath, 'utf-8').trim().split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i]!.includes(`"${taskId}"`)) return lines[i]!;
-  }
-  return null;
+import {
+  type ProtocolValidationResult,
+  type VotingMatrix,
+  validateConsensusProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
+
+function loadVotingMatrix(votingMatrixFile: string | undefined): VotingMatrix {
+  if (!votingMatrixFile || !existsSync(votingMatrixFile)) return { options: [] };
+  const raw = JSON.parse(readFileSync(votingMatrixFile, 'utf-8')) as Partial<VotingMatrix> & {
+    options?: unknown;
+  };
+  const options = Array.isArray(raw.options) ? raw.options : Object.values(raw.options ?? {});
+  return {
+    options: options.filter(
+      (o): o is { name: string; confidence: number; rationale?: string } =>
+        typeof o === 'object' && o !== null && 'name' in o && 'confidence' in o,
+    ),
+    threshold: raw.threshold,
+  };
 }
 
 /** Validate consensus protocol for a task. */
 export async function validateConsensusTask(
   taskId: string,
   opts: { strict?: boolean; votingMatrixFile?: string },
-): Promise<ValidationResult> {
-  const manifestPath = getManifestPath();
-  const entry = findManifestEntry(taskId, manifestPath);
-  if (!entry) {
-    throw new CleoError(ExitCode.NOT_FOUND, `No manifest entry found for task ${taskId}`);
-  }
-
-  const manifest = JSON.parse(entry);
-  const violations: ValidationResult['violations'] = [];
-
-  // CONS-007: agent_type check
-  if (manifest.agent_type !== 'analysis') {
-    violations.push({
-      code: 'CONS-007',
-      severity: 'high',
-      message: `Expected agent_type "analysis", got "${manifest.agent_type}"`,
-    });
-  }
-
-  // Load voting matrix if provided
-  if (opts.votingMatrixFile && existsSync(opts.votingMatrixFile)) {
-    const matrix = JSON.parse(readFileSync(opts.votingMatrixFile, 'utf-8'));
-    const options = Object.keys(matrix.options ?? {});
-    if (options.length < 2) {
-      violations.push({
-        code: 'CONS-001',
-        severity: 'high',
-        message: 'Voting matrix requires at least 2 options',
-      });
-    }
-  }
-
-  const score = violations.length === 0 ? 100 : Math.max(0, 100 - violations.length * 25);
-  const result: ValidationResult = {
-    valid: violations.length === 0,
-    violations,
-    score,
-    protocol: 'consensus',
-    taskId,
-  };
-
-  if (opts.strict && violations.length > 0) {
-    throw new CleoError(61 as ExitCode, `Consensus protocol violations for ${taskId}`);
-  }
-
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const matrix = loadVotingMatrix(opts.votingMatrixFile);
+  const result = validateConsensusProtocol(entry, matrix);
+  throwIfStrictFailed(result, opts, 'consensus', taskId);
   return result;
 }
 
-/** Validate consensus protocol from manifest file. */
+/** Validate consensus protocol from a manifest file. */
 export async function checkConsensusManifest(
   manifestFile: string,
   opts: { strict?: boolean; votingMatrixFile?: string },
-): Promise<ValidationResult> {
-  if (!existsSync(manifestFile)) {
-    throw new CleoError(ExitCode.NOT_FOUND, `Manifest file not found: ${manifestFile}`);
-  }
-  const manifest = JSON.parse(readFileSync(manifestFile, 'utf-8'));
-  const taskId = manifest.linked_tasks?.[0] ?? 'UNKNOWN';
-  return validateConsensusTask(taskId, opts);
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const matrix = loadVotingMatrix(opts.votingMatrixFile);
+  const result = validateConsensusProtocol(entry, matrix);
+  throwIfStrictFailed(result, opts, 'consensus', taskId);
+  return result;
 }

package/src/validation/protocols/contribution.ts

@@ -1,79 +1,42 @@
 /**
- * Contribution protocol validation.
+ * Contribution protocol — thin wrapper delegating to the canonical pure validator.
+ *
+ * Contribution is a cross-cutting protocol that tracks multi-agent attribution
+ * at the implementation stage (see default-chain.ts DEFAULT_PROTOCOL_STAGE_MAP).
+ *
  * @task T4537
- * @epic T4454
+ * @task T260
  */
 
-import { existsSync, readFileSync } from 'node:fs';
-import { ExitCode } from '@cleocode/contracts';
-import { CleoError } from '../../errors.js';
-import { getManifestPath } from '../../paths.js';
-
-interface ValidationResult {
-  valid: boolean;
-  violations: Array<{ code: string; severity: string; message: string }>;
-  score: number;
-  protocol: string;
-  taskId: string;
-}
-
-function findManifestEntry(taskId: string, manifestPath: string): string | null {
-  if (!existsSync(manifestPath)) return null;
-  const lines = readFileSync(manifestPath, 'utf-8').trim().split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i]!.includes(`"${taskId}"`)) return lines[i]!;
-  }
-  return null;
-}
+import {
+  type ProtocolValidationResult,
+  validateContributionProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
 
 /** Validate contribution protocol for a task. */
 export async function validateContributionTask(
   taskId: string,
-  opts: { strict?: boolean },
-): Promise<ValidationResult> {
-  const manifestPath = getManifestPath();
-  const entry = findManifestEntry(taskId, manifestPath);
-  if (!entry) {
-    throw new CleoError(ExitCode.NOT_FOUND, `No manifest entry found for task ${taskId}`);
-  }
-
-  const manifest = JSON.parse(entry);
-  const violations: ValidationResult['violations'] = [];
-
-  // CONT-007: agent_type check
-  if (manifest.agent_type !== 'implementation') {
-    violations.push({
-      code: 'CONT-007',
-      severity: 'high',
-      message: `Expected agent_type "implementation", got "${manifest.agent_type}"`,
-    });
-  }
-
-  const score = violations.length === 0 ? 100 : Math.max(0, 100 - violations.length * 25);
-  const result: ValidationResult = {
-    valid: violations.length === 0,
-    violations,
-    score,
-    protocol: 'contribution',
-    taskId,
-  };
-
-  if (opts.strict && violations.length > 0) {
-    throw new CleoError(65 as ExitCode, `Contribution protocol violations for ${taskId}`);
-  }
-
+  opts: { strict?: boolean; hasContributionTags?: boolean },
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const result = validateContributionProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'contribution', taskId);
   return result;
 }
 
-/** Validate contribution protocol from manifest file. */
+/** Validate contribution protocol from a manifest file. */
 export async function checkContributionManifest(
   manifestFile: string,
-  opts: { strict?: boolean },
-): Promise<ValidationResult> {
-  if (!existsSync(manifestFile)) {
-    throw new CleoError(ExitCode.NOT_FOUND, `Manifest file not found: ${manifestFile}`);
-  }
-  const manifest = JSON.parse(readFileSync(manifestFile, 'utf-8'));
-  const taskId = manifest.linked_tasks?.[0] ?? 'UNKNOWN';
-  return validateContributionTask(taskId, opts);
+  opts: { strict?: boolean; hasContributionTags?: boolean },
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const result = validateContributionProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'contribution', taskId);
+  return result;
 }

package/src/validation/protocols/decomposition.ts

@@ -1,79 +1,52 @@
 /**
- * Decomposition protocol validation.
+ * Decomposition protocol — thin wrapper delegating to the canonical pure validator.
+ *
+ * The canonical validator enforces DCOMP-001 (max siblings), DCOMP-002 (clarity),
+ * DCOMP-007 (`agent_type: decomposition`). The old validator here checked for
+ * `agent_type: specification` which was a copy-paste bug from specification.ts.
+ *
  * @task T4537
- * @epic T4454
+ * @task T260 — delegate to orchestration/protocol-validators, fix agent_type
  */
 
-import { existsSync, readFileSync } from 'node:fs';
-import { ExitCode } from '@cleocode/contracts';
-import { CleoError } from '../../errors.js';
-import { getManifestPath } from '../../paths.js';
-
-interface ValidationResult {
-  valid: boolean;
-  violations: Array<{ code: string; severity: string; message: string }>;
-  score: number;
-  protocol: string;
-  taskId: string;
-}
-
-function findManifestEntry(taskId: string, manifestPath: string): string | null {
-  if (!existsSync(manifestPath)) return null;
-  const lines = readFileSync(manifestPath, 'utf-8').trim().split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i]!.includes(`"${taskId}"`)) return lines[i]!;
-  }
-  return null;
+import {
+  type ProtocolValidationResult,
+  validateDecompositionProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
+
+interface DecompositionOpts {
+  strict?: boolean;
+  epicId?: string;
+  siblingCount?: number;
+  descriptionClarity?: boolean;
+  maxSiblings?: number;
+  maxDepth?: number;
 }
 
 /** Validate decomposition protocol for a task. */
 export async function validateDecompositionTask(
   taskId: string,
-  opts: { strict?: boolean; epicId?: string },
-): Promise<ValidationResult> {
-  const manifestPath = getManifestPath();
-  const entry = findManifestEntry(taskId, manifestPath);
-  if (!entry) {
-    throw new CleoError(ExitCode.NOT_FOUND, `No manifest entry found for task ${taskId}`);
-  }
-
-  const manifest = JSON.parse(entry);
-  const violations: ValidationResult['violations'] = [];
-
-  // DCMP-007: agent_type check
-  if (manifest.agent_type !== 'specification') {
-    violations.push({
-      code: 'DCMP-007',
-      severity: 'high',
-      message: `Expected agent_type "specification", got "${manifest.agent_type}"`,
-    });
-  }
-
-  const score = violations.length === 0 ? 100 : Math.max(0, 100 - violations.length * 25);
-  const result: ValidationResult = {
-    valid: violations.length === 0,
-    violations,
-    score,
-    protocol: 'decomposition',
-    taskId,
-  };
-
-  if (opts.strict && violations.length > 0) {
-    throw new CleoError(63 as ExitCode, `Decomposition protocol violations for ${taskId}`);
-  }
-
+  opts: DecompositionOpts,
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const result = validateDecompositionProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'decomposition', taskId);
   return result;
 }
 
-/** Validate decomposition protocol from manifest file. */
+/** Validate decomposition protocol from a manifest file. */
 export async function checkDecompositionManifest(
   manifestFile: string,
-  opts: { strict?: boolean; epicId?: string },
-): Promise<ValidationResult> {
-  if (!existsSync(manifestFile)) {
-    throw new CleoError(ExitCode.NOT_FOUND, `Manifest file not found: ${manifestFile}`);
-  }
-  const manifest = JSON.parse(readFileSync(manifestFile, 'utf-8'));
-  const taskId = manifest.linked_tasks?.[0] ?? 'UNKNOWN';
-  return validateDecompositionTask(taskId, opts);
+  opts: DecompositionOpts,
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const result = validateDecompositionProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'decomposition', taskId);
+  return result;
 }

package/src/validation/protocols/implementation.ts

@@ -1,79 +1,39 @@
 /**
- * Implementation protocol validation.
+ * Implementation protocol — thin wrapper delegating to the canonical pure validator.
+ *
  * @task T4537
- * @epic T4454
+ * @task T260
  */
 
-import { existsSync, readFileSync } from 'node:fs';
-import { ExitCode } from '@cleocode/contracts';
-import { CleoError } from '../../errors.js';
-import { getManifestPath } from '../../paths.js';
-
-interface ValidationResult {
-  valid: boolean;
-  violations: Array<{ code: string; severity: string; message: string }>;
-  score: number;
-  protocol: string;
-  taskId: string;
-}
-
-function findManifestEntry(taskId: string, manifestPath: string): string | null {
-  if (!existsSync(manifestPath)) return null;
-  const lines = readFileSync(manifestPath, 'utf-8').trim().split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    if (lines[i]!.includes(`"${taskId}"`)) return lines[i]!;
-  }
-  return null;
-}
+import {
+  type ProtocolValidationResult,
+  validateImplementationProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
 
 /** Validate implementation protocol for a task. */
 export async function validateImplementationTask(
   taskId: string,
-  opts: { strict?: boolean },
-): Promise<ValidationResult> {
-  const manifestPath = getManifestPath();
-  const entry = findManifestEntry(taskId, manifestPath);
-  if (!entry) {
-    throw new CleoError(ExitCode.NOT_FOUND, `No manifest entry found for task ${taskId}`);
-  }
-
-  const manifest = JSON.parse(entry);
-  const violations: ValidationResult['violations'] = [];
-
-  // IMPL-007: agent_type check
-  if (manifest.agent_type !== 'implementation') {
-    violations.push({
-      code: 'IMPL-007',
-      severity: 'high',
-      message: `Expected agent_type "implementation", got "${manifest.agent_type}"`,
-    });
-  }
-
-  const score = violations.length === 0 ? 100 : Math.max(0, 100 - violations.length * 25);
-  const result: ValidationResult = {
-    valid: violations.length === 0,
-    violations,
-    score,
-    protocol: 'implementation',
-    taskId,
-  };
-
-  if (opts.strict && violations.length > 0) {
-    throw new CleoError(64 as ExitCode, `Implementation protocol violations for ${taskId}`);
-  }
-
+  opts: { strict?: boolean; hasTaskTags?: boolean },
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const result = validateImplementationProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'implementation', taskId);
   return result;
 }
 
-/** Validate implementation protocol from manifest file. */
+/** Validate implementation protocol from a manifest file. */
 export async function checkImplementationManifest(
   manifestFile: string,
-  opts: { strict?: boolean },
-): Promise<ValidationResult> {
-  if (!existsSync(manifestFile)) {
-    throw new CleoError(ExitCode.NOT_FOUND, `Manifest file not found: ${manifestFile}`);
-  }
-  const manifest = JSON.parse(readFileSync(manifestFile, 'utf-8'));
-  const taskId = manifest.linked_tasks?.[0] ?? 'UNKNOWN';
-  return validateImplementationTask(taskId, opts);
+  opts: { strict?: boolean; hasTaskTags?: boolean },
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const result = validateImplementationProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'implementation', taskId);
+  return result;
 }