@cleocode/core 2026.4.5 → 2026.4.7

package/src/validation/protocols/research.ts

@@ -1,101 +1,39 @@
 /**
- * Research protocol validation.
+ * Research protocol — thin wrapper delegating to the canonical pure validator.
+ *
  * @task T4804
- * @epic T4798
+ * @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,
+  validateResearchProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
 
 /** Validate research protocol for a task. */
 export async function validateResearchTask(
   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'] = [];
-
-  // RSCH-001: agent_type check
-  if (manifest.agent_type !== 'research') {
-    violations.push({
-      code: 'RSCH-001',
-      severity: 'high',
-      message: `Expected agent_type "research", got "${manifest.agent_type}"`,
-    });
-  }
-
-  // RSCH-002: key_findings must be present and non-empty
-  if (
-    !manifest.key_findings ||
-    !Array.isArray(manifest.key_findings) ||
-    manifest.key_findings.length === 0
-  ) {
-    violations.push({
-      code: 'RSCH-002',
-      severity: 'high',
-      message: 'Research output must include non-empty key_findings array',
-    });
-  }
-
-  // RSCH-003: output file must exist
-  if (manifest.file && !existsSync(manifest.file)) {
-    violations.push({
-      code: 'RSCH-003',
-      severity: 'medium',
-      message: `Output file "${manifest.file}" not found on disk`,
-    });
-  }
-
-  const score = violations.length === 0 ? 100 : Math.max(0, 100 - violations.length * 25);
-  const result: ValidationResult = {
-    valid: violations.length === 0,
-    violations,
-    score,
-    protocol: 'research',
-    taskId,
-  };
-
-  if (opts.strict && violations.length > 0) {
-    throw new CleoError(60 as ExitCode, `Research protocol violations for ${taskId}`);
-  }
-
+  opts: { strict?: boolean; hasCodeChanges?: boolean },
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const result = validateResearchProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'research', taskId);
   return result;
 }
 
-/** Validate research protocol from manifest file. */
+/** Validate research protocol from a manifest file. */
 export async function checkResearchManifest(
   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 validateResearchTask(taskId, opts);
+  opts: { strict?: boolean; hasCodeChanges?: boolean },
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const result = validateResearchProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'research', taskId);
+  return result;
 }

package/src/validation/protocols/specification.ts

@@ -1,106 +1,44 @@
 /**
- * Specification protocol validation.
+ * Specification 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,
+  validateSpecificationProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
 
 /** Validate specification protocol for a task. */
 export async function validateSpecificationTask(
   taskId: string,
   opts: { strict?: boolean; specFile?: 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'] = [];
-
-  // SPEC-007: agent_type check
-  if (manifest.agent_type !== 'specification') {
-    violations.push({
-      code: 'SPEC-007',
-      severity: 'high',
-      message: `Expected agent_type "specification", got "${manifest.agent_type}"`,
-    });
-  }
-
-  // SPEC-001: RFC 2119 keywords check
-  if (opts.specFile && existsSync(opts.specFile)) {
-    const specContent = readFileSync(opts.specFile, 'utf-8');
-    const rfc2119Keywords = ['MUST', 'SHOULD', 'MAY', 'MUST NOT', 'SHOULD NOT'];
-    const hasKeywords = rfc2119Keywords.some((kw) => specContent.includes(kw));
-    if (!hasKeywords) {
-      violations.push({
-        code: 'SPEC-001',
-        severity: 'medium',
-        message: 'Specification should contain RFC 2119 keywords (MUST/SHOULD/MAY)',
-      });
-    }
-  }
-
-  // SPEC-002: version check
-  if (!manifest.version && opts.specFile) {
-    const specContent = existsSync(opts.specFile) ? readFileSync(opts.specFile, 'utf-8') : '';
-    const hasVersion = /version[:\s]+\d/i.test(specContent) || /^#+.*v\d/im.test(specContent);
-    if (!hasVersion) {
-      violations.push({
-        code: 'SPEC-002',
-        severity: 'medium',
-        message: 'Specification should include version information',
-      });
-    }
-  }
-
-  const score = violations.length === 0 ? 100 : Math.max(0, 100 - violations.length * 20);
-  const result: ValidationResult = {
-    valid: violations.length === 0,
-    violations,
-    score,
-    protocol: 'specification',
-    taskId,
-  };
-
-  if (opts.strict && violations.length > 0) {
-    throw new CleoError(62 as ExitCode, `Specification protocol violations for ${taskId}`);
-  }
-
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const specContent =
+    opts.specFile && existsSync(opts.specFile) ? readFileSync(opts.specFile, 'utf-8') : undefined;
+  const result = validateSpecificationProtocol(entry, specContent);
+  throwIfStrictFailed(result, opts, 'specification', taskId);
   return result;
 }
 
-/** Validate specification protocol from manifest file. */
+/** Validate specification protocol from a manifest file. */
 export async function checkSpecificationManifest(
   manifestFile: string,
   opts: { strict?: boolean; specFile?: 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 validateSpecificationTask(taskId, opts);
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const specContent =
+    opts.specFile && existsSync(opts.specFile) ? readFileSync(opts.specFile, 'utf-8') : undefined;
+  const result = validateSpecificationProtocol(entry, specContent);
+  throwIfStrictFailed(result, opts, 'specification', taskId);
+  return result;
 }

package/src/validation/protocols/testing.ts

@@ -0,0 +1,46 @@
+/**
+ * Testing protocol — thin wrapper delegating to the canonical pure validator.
+ *
+ * Renamed from testing-protocol.ts in T260. The testing protocol is the
+ * project-agnostic IVT loop closure stage: it checks that a detected test
+ * framework ran, achieved 100% pass rate, and the Implement→Validate→Test
+ * loop converged on the specification. Framework detection and loop logic
+ * live in the `ct-ivt-looper` skill; this validator only certifies results.
+ *
+ * @task T4804
+ * @task T260 — drop -protocol suffix, delegate, project-agnostic IVT
+ */
+
+import {
+  type ProtocolValidationResult,
+  type TestingOptions,
+  validateTestingProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
+
+/** Validate testing protocol for a task. */
+export async function validateTestingTask(
+  taskId: string,
+  opts: { strict?: boolean } & TestingOptions,
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const result = validateTestingProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'testing', taskId);
+  return result;
+}
+
+/** Validate testing protocol from a manifest file. */
+export async function checkTestingManifest(
+  manifestFile: string,
+  opts: { strict?: boolean } & TestingOptions,
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const result = validateTestingProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'testing', taskId);
+  return result;
+}

package/src/validation/protocols/validation.ts

@@ -0,0 +1,46 @@
+/**
+ * Validation protocol — thin wrapper delegating to the canonical pure validator.
+ *
+ * Renamed from validation-protocol.ts in T260. The validation stage runs
+ * static analysis, type checking, and pre-test quality gates. It is the
+ * first half of the IVT loop (Implement → Validate → Test); the validator
+ * here only verifies that a validation run produced a proper manifest
+ * entry — runtime gate enforcement is in the lifecycle state machine.
+ *
+ * @task T4804
+ * @task T260 — drop -protocol suffix, delegate to orchestration validator
+ */
+
+import {
+  type ProtocolValidationResult,
+  type ValidationStageOptions,
+  validateValidationProtocol,
+} from '../../orchestration/protocol-validators.js';
+import {
+  loadManifestEntryByTaskId,
+  loadManifestEntryFromFile,
+  throwIfStrictFailed,
+} from './_shared.js';
+
+/** Validate validation-stage protocol for a task. */
+export async function validateValidationTask(
+  taskId: string,
+  opts: { strict?: boolean } & ValidationStageOptions,
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryByTaskId(taskId);
+  const result = validateValidationProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'validation', taskId);
+  return result;
+}
+
+/** Validate validation-stage protocol from a manifest file. */
+export async function checkValidationManifest(
+  manifestFile: string,
+  opts: { strict?: boolean } & ValidationStageOptions,
+): Promise<ProtocolValidationResult> {
+  const entry = loadManifestEntryFromFile(manifestFile);
+  const taskId = entry.linked_tasks?.[0] ?? 'UNKNOWN';
+  const result = validateValidationProtocol(entry, opts);
+  throwIfStrictFailed(result, opts, 'validation', taskId);
+  return result;
+}

package/dist/cant/approval.d.ts

@@ -1,110 +0,0 @@
-/**
- * Approval gate manager for CANT workflow execution.
- *
- * Manages the lifecycle of approval tokens: generation, validation,
- * approval, rejection, and expiration. Tokens follow the state machine
- * defined in CANT-DSL-SPEC.md Section 8.2.
- *
- * State transitions are atomic (CAS): only `pending -> approved`,
- * `pending -> rejected`, and `pending -> expired` are permitted.
- *
- * @see docs/specs/CANT-DSL-SPEC.md Section 8 (Approval Token Protocol)
- */
-import type { ApprovalToken, TokenValidation } from './types.js';
-/**
- * Manages approval tokens for CANT workflow gates.
- *
- * Tokens are stored in-memory per instance. In production, these are
- * persisted via the session's `approvalTokensJson` column in tasks.db.
- */
-export declare class ApprovalManager {
-    /** In-memory token store keyed by token UUID. */
-    private tokens;
-    /**
-     * Generates a new approval token for a workflow gate.
-     *
-     * @param sessionId - The session that owns this token.
-     * @param workflowName - The workflow containing the approval gate.
-     * @param gateName - The label of the specific approval gate.
-     * @param message - The message to display to the approver.
-     * @param workflowHash - SHA-256 hash of the workflow definition.
-     * @param requestedBy - The agent/workflow requesting approval.
-     * @param expiresInMs - Token lifetime in milliseconds (default: 24h).
-     * @returns The generated approval token.
-     */
-    generateToken(sessionId: string, workflowName: string, gateName: string, message: string, workflowHash: string, requestedBy: string, expiresInMs?: number): ApprovalToken;
-    /**
-     * Validates an approval token against the current execution context.
-     *
-     * Checks: (a) token exists, (b) sessionId matches, (c) status is pending,
-     * (d) not expired, (e) workflowHash matches current workflow.
-     *
-     * @param tokenId - The token UUID to validate.
-     * @param currentSessionId - The current session to validate against.
-     * @param currentWorkflowHash - The current workflow hash for TOCTOU check.
-     * @returns Validation result with reason if invalid.
-     */
-    validateToken(tokenId: string, currentSessionId: string, currentWorkflowHash: string): TokenValidation;
-    /**
-     * Approves a pending token.
-     *
-     * Performs an atomic CAS transition: `pending -> approved`. If the token
-     * is not in `pending` state, the operation is a no-op and returns false.
-     *
-     * @param tokenId - The token UUID to approve.
-     * @param approvedBy - The identifier of the approving actor.
-     * @returns `true` if the transition succeeded, `false` if CAS failed.
-     */
-    approveToken(tokenId: string, approvedBy: string): boolean;
-    /**
-     * Rejects a pending token.
-     *
-     * Performs an atomic CAS transition: `pending -> rejected`.
-     *
-     * @param tokenId - The token UUID to reject.
-     * @returns `true` if the transition succeeded, `false` if CAS failed.
-     */
-    rejectToken(tokenId: string): boolean;
-    /**
-     * Expires a pending token.
-     *
-     * Performs an atomic CAS transition: `pending -> expired`.
-     *
-     * @param tokenId - The token UUID to expire.
-     * @returns `true` if the transition succeeded, `false` if CAS failed.
-     */
-    expireToken(tokenId: string): boolean;
-    /**
-     * Retrieves a token by its UUID.
-     *
-     * @param tokenId - The token UUID to look up.
-     * @returns The token if found, otherwise undefined.
-     */
-    getToken(tokenId: string): ApprovalToken | undefined;
-    /**
-     * Lists all tokens for a given session.
-     *
-     * @param sessionId - The session to filter by.
-     * @returns Array of tokens belonging to the session.
-     */
-    getTokensForSession(sessionId: string): ApprovalToken[];
-    /**
-     * Computes a SHA-256 hash of a workflow definition string.
-     *
-     * Used for TOCTOU protection: the hash at token creation time is compared
-     * against the hash at approval time.
-     *
-     * @param workflowText - The raw workflow definition text.
-     * @returns Hex-encoded SHA-256 hash.
-     */
-    static computeWorkflowHash(workflowText: string): string;
-    /**
-     * Atomically transitions a token from `pending` to the target status.
-     *
-     * @param tokenId - The token UUID.
-     * @param targetStatus - The desired new status.
-     * @returns `true` if the CAS transition succeeded.
-     */
-    private transitionStatus;
-}
-//# sourceMappingURL=approval.d.ts.map

package/dist/cant/approval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"approval.d.ts","sourceRoot":"","sources":["../../src/cant/approval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAuB,eAAe,EAAE,MAAM,YAAY,CAAC;AAKtF;;;;;GAKG;AACH,qBAAa,eAAe;IAC1B,iDAAiD;IACjD,OAAO,CAAC,MAAM,CAAyC;IAEvD;;;;;;;;;;;OAWG;IACH,aAAa,CACX,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,WAAW,GAAE,MAA0B,GACtC,aAAa;IAmBhB;;;;;;;;;;OAUG;IACH,aAAa,CACX,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,EACxB,mBAAmB,EAAE,MAAM,GAC1B,eAAe;IA8BlB;;;;;;;;;OASG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAc1D;;;;;;;OAOG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAWrC;;;;;;;OAOG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIpD;;;;;OAKG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,aAAa,EAAE;IAIvD;;;;;;;;OAQG;IACH,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAIxD;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;CASzB"}

package/dist/cant/context-builder.d.ts

@@ -1,79 +0,0 @@
-/**
- * Execution context builder for CANT workflows.
- *
- * Resolves variable references and manages the scope chain for workflow
- * execution. Variables from workflow parameters, step outputs, and
- * intermediate bindings are tracked in a hierarchical scope.
- *
- * @see docs/specs/CANT-DSL-SPEC.md Section 7.2 (Workflow Execution)
- */
-import type { ExecutionScope } from './types.js';
-/**
- * Creates a new root execution scope with initial variable bindings.
- *
- * @param initialBindings - Initial variable values (typically workflow parameters).
- * @returns A new root scope.
- */
-export declare function createScope(initialBindings?: Record<string, unknown>): ExecutionScope;
-/**
- * Creates a child scope that inherits from a parent.
- *
- * Lookups in the child scope fall through to the parent if not found locally.
- * This is used for parallel arms, loop iterations, and nested blocks.
- *
- * @param parent - The parent scope.
- * @param localBindings - Local variable overrides for this child scope.
- * @returns A new child scope.
- */
-export declare function createChildScope(parent: ExecutionScope, localBindings?: Record<string, unknown>): ExecutionScope;
-/**
- * Resolves a variable name in the scope chain.
- *
- * Searches the current scope first, then walks up the parent chain.
- *
- * @param scope - The scope to search in.
- * @param name - The variable name to resolve.
- * @returns The variable value, or `undefined` if not found in any scope.
- */
-export declare function resolveVariable(scope: ExecutionScope, name: string): unknown;
-/**
- * Sets a variable in the current scope (does not affect parent scopes).
- *
- * @param scope - The scope to modify.
- * @param name - The variable name to set.
- * @param value - The value to assign.
- */
-export declare function setVariable(scope: ExecutionScope, name: string, value: unknown): void;
-/**
- * Resolves `{variable}` placeholders in a template string against the scope.
- *
- * Performs single-pass replacement per the T07 security rule: nested
- * interpolation within resolved values is treated as literal text.
- *
- * @param template - The string containing `{variable}` placeholders.
- * @param scope - The execution scope for variable resolution.
- * @returns The string with all placeholders resolved.
- * @throws {Error} If a referenced variable is not found in any scope.
- */
-export declare function resolveTemplate(template: string, scope: ExecutionScope): string;
-/**
- * Merges step output into the current scope.
- *
- * Binds `<stepName>.stdout`, `<stepName>.stderr`, and `<stepName>.exitCode`
- * for use in subsequent step variable resolution.
- *
- * @param scope - The scope to add bindings to.
- * @param stepName - The name of the completed step.
- * @param output - The step output to merge.
- */
-export declare function mergeStepOutput(scope: ExecutionScope, stepName: string, output: Record<string, unknown>): void;
-/**
- * Collects all variable bindings visible from the given scope (including parents).
- *
- * Parent bindings are overridden by child bindings of the same name.
- *
- * @param scope - The scope to flatten.
- * @returns A flat record of all visible variable bindings.
- */
-export declare function flattenScope(scope: ExecutionScope): Record<string, unknown>;
-//# sourceMappingURL=context-builder.d.ts.map

package/dist/cant/context-builder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-builder.d.ts","sourceRoot":"","sources":["../../src/cant/context-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,cAAc,CAIzF;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,cAAc,EACtB,aAAa,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAC1C,cAAc,CAKhB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAY5E;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAErF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,MAAM,CAQ/E;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,IAAI,CAQN;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAG3E"}

package/dist/cant/discretion.d.ts

@@ -1,95 +0,0 @@
-/**
- * Discretion evaluation for CANT workflow conditionals.
- *
- * Discretion conditions (`**prose text**`) are AI-evaluated logic gates
- * in CANT workflows. The evaluation is pluggable: the default evaluator
- * stubs `true` (real LLM integration is a separate task), while custom
- * evaluators can be injected for testing, rule-based shortcuts, or
- * alternative model backends.
- *
- * @see docs/specs/CANT-DSL-SPEC.md Section 7.3 (Discretion Evaluation)
- */
-import type { DiscretionContext } from './types.js';
-/** Evaluates a discretion condition and returns a boolean judgment. */
-export interface DiscretionEvaluator {
-    /**
-     * Evaluate whether a discretion condition is met.
-     *
-     * @param condition - The prose text between `**` delimiters.
-     * @param context - Execution context including session, variables, and prior results.
-     * @returns `true` if the condition is judged to be met.
-     */
-    evaluate(condition: string, context: DiscretionContext): Promise<boolean>;
-}
-/**
- * Default discretion evaluator that always returns `true`.
- *
- * This is a stub implementation. The real LLM-backed evaluator will be
- * implemented as a separate task. In production, this should be replaced
- * with an evaluator that:
- * - Calls the LLM API with the condition in a structured field
- * - Uses structured prompting (tool use / JSON mode)
- * - Returns a boolean judgment
- */
-export declare class DefaultDiscretionEvaluator implements DiscretionEvaluator {
-    /** Always returns `true` (stub). */
-    evaluate(_condition: string, _context: DiscretionContext): Promise<boolean>;
-}
-/**
- * Mock discretion evaluator with configurable responses for testing.
- *
- * Responses can be set per condition text or as a blanket default.
- */
-export declare class MockDiscretionEvaluator implements DiscretionEvaluator {
-    private responses;
-    private defaultResponse;
-    private evaluationLog;
-    /**
-     * Creates a mock evaluator.
-     *
-     * @param defaultResponse - The response for conditions without a specific mapping.
-     */
-    constructor(defaultResponse?: boolean);
-    /** Set the response for a specific condition text. */
-    setResponse(condition: string, result: boolean): void;
-    /** Evaluate using the configured response map. */
-    evaluate(condition: string, context: DiscretionContext): Promise<boolean>;
-    /** Get the log of all evaluations performed. */
-    getLog(): ReadonlyArray<{
-        condition: string;
-        context: DiscretionContext;
-        result: boolean;
-    }>;
-    /** Reset the evaluation log. */
-    clearLog(): void;
-}
-/**
- * Wraps a discretion evaluator with rate limiting.
- *
- * Enforces a configurable maximum number of discretion evaluations per
- * workflow execution. Default limit is 100 per the spec. This prevents
- * runaway costs from loops containing discretion conditions.
- */
-export declare class RateLimitedDiscretionEvaluator implements DiscretionEvaluator {
-    private readonly inner;
-    private readonly maxEvaluations;
-    private evaluationCount;
-    /**
-     * Creates a rate-limited evaluator wrapper.
-     *
-     * @param inner - The underlying evaluator to delegate to.
-     * @param maxEvaluations - Maximum evaluations allowed (default: 100).
-     */
-    constructor(inner: DiscretionEvaluator, maxEvaluations?: number);
-    /**
-     * Evaluate with rate limiting.
-     *
-     * @throws {Error} If the evaluation count exceeds the configured maximum.
-     */
-    evaluate(condition: string, context: DiscretionContext): Promise<boolean>;
-    /** Get the current evaluation count. */
-    getEvaluationCount(): number;
-    /** Reset the evaluation counter (for reuse across workflow runs). */
-    resetCount(): void;
-}
-//# sourceMappingURL=discretion.d.ts.map

package/dist/cant/discretion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discretion.d.ts","sourceRoot":"","sources":["../../src/cant/discretion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAMpD,uEAAuE;AACvE,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3E;AAMD;;;;;;;;;GASG;AACH,qBAAa,0BAA2B,YAAW,mBAAmB;IACpE,oCAAoC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC;CAGlF;AAMD;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IACjE,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,eAAe,CAAU;IACjC,OAAO,CAAC,aAAa,CAChB;IAEL;;;;OAIG;gBACS,eAAe,UAAO;IAIlC,sDAAsD;IACtD,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAIrD,kDAAkD;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC;IAM/E,gDAAgD;IAChD,MAAM,IAAI,aAAa,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,iBAAiB,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IAI3F,gCAAgC;IAChC,QAAQ,IAAI,IAAI;CAGjB;AAMD;;;;;;GAMG;AACH,qBAAa,8BAA+B,YAAW,mBAAmB;IAUtE,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAVjC,OAAO,CAAC,eAAe,CAAK;IAE5B;;;;;OAKG;gBAEgB,KAAK,EAAE,mBAAmB,EAC1B,cAAc,GAAE,MAAY;IAG/C;;;;OAIG;IACG,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC;IAW/E,wCAAwC;IACxC,kBAAkB,IAAI,MAAM;IAI5B,qEAAqE;IACrE,UAAU,IAAI,IAAI;CAGnB"}