@cleocode/cleo 2026.10.4 → 2026.10.5-rc.ci.672

package/dist/cli/check-C67YAU7W.js

@@ -0,0 +1,759 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch
+} from "./chunk-QWNKLLLG.js";
+import {
+  lazyOperation
+} from "./chunk-TYC7G5LF.js";
+import {
+  dispatchMeta,
+  handleErrorResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/check.ts
+import { resolveWorktreeRouting } from "@cleocode/core/core-paths";
+import { getLogger } from "@cleocode/core/logger";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import {
+  checkComplianceRecord,
+  checkComplianceSummary,
+  checkTestCoverage,
+  checkTestRun,
+  checkTestStatus,
+  checkValidateManifest,
+  checkValidateOutput
+} from "@cleocode/core/validation/ops";
+var checkArchiveStats = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkArchiveStats
+);
+var checkCoherence = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkCoherence
+);
+var checkComplianceSync = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkComplianceSync
+);
+var checkExplainVerification = lazyOperation(
+  async () => (await import("@cleocode/core/lifecycle/verification/explain")).checkExplainVerification
+);
+var checkGradeSession = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkGradeSession
+);
+var checkReadGrades = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkReadGrades
+);
+var checkValidateProtocol = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkValidateProtocol
+);
+var checkValidateSchema = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkValidateSchema
+);
+var checkValidateTask = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkValidateTask
+);
+var checkWorkflowCompliance = lazyOperation(
+  async () => (await import("@cleocode/core/validation/ops")).checkWorkflowCompliance
+);
+var previewTaskGates = lazyOperation(
+  async () => (await import("@cleocode/core/tasks/gate-preview")).previewTaskGates
+);
+var validateGateVerify = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateGateVerify
+);
+var validateProtocolArchitectureDecision = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolArchitectureDecision
+);
+var validateProtocolArtifactPublish = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolArtifactPublish
+);
+var validateProtocolConsensus = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolConsensus
+);
+var validateProtocolContribution = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolContribution
+);
+var validateProtocolDecomposition = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolDecomposition
+);
+var validateProtocolImplementation = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolImplementation
+);
+var validateProtocolProvenance = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolProvenance
+);
+var validateProtocolRelease = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolRelease
+);
+var validateProtocolResearch = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolResearch
+);
+var validateProtocolSpecification = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolSpecification
+);
+var validateProtocolTesting = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolTesting
+);
+var validateProtocolValidation = lazyOperation(
+  async () => (await import("@cleocode/core/validation/engine-ops")).validateProtocolValidation
+);
+var _checkTypedHandler = defineTypedHandler("check", {
+  // -----------------------------------------------------------------------
+  // Query ops
+  // -----------------------------------------------------------------------
+  schema: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.type) {
+      return lafsError("E_INVALID_INPUT", "type is required", "schema");
+    }
+    try {
+      const result = await checkValidateSchema(projectRoot, params);
+      return lafsSuccess(result, "schema");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = message.includes("not found") ? "E_NOT_FOUND" : message.includes("Unknown schema") ? "E_INVALID_TYPE" : message.includes("required") ? "E_INVALID_INPUT" : "E_VALIDATION_ERROR";
+      return lafsError(code, message, "schema");
+    }
+  },
+  task: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.taskId) {
+      return lafsError("E_INVALID_INPUT", "taskId is required", "task");
+    }
+    try {
+      const result = await checkValidateTask(projectRoot, params);
+      return lafsSuccess(result, "task");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_INPUT";
+      return lafsError(code, message, "task");
+    }
+  },
+  manifest: async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = checkValidateManifest(projectRoot, params);
+      return lafsSuccess(result, "manifest");
+    } catch (err) {
+      return lafsError(
+        "E_FILE_ERROR",
+        err instanceof Error ? err.message : String(err),
+        "manifest"
+      );
+    }
+  },
+  output: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.filePath) {
+      return lafsError("E_INVALID_INPUT", "filePath is required", "output");
+    }
+    try {
+      const result = checkValidateOutput(projectRoot, params);
+      return lafsSuccess(result, "output");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const code = message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_INPUT";
+      return lafsError(code, message, "output");
+    }
+  },
+  "compliance.summary": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const summary = checkComplianceSummary(projectRoot, params);
+      const enrichedData = {
+        ...summary,
+        view: params.type ?? "summary",
+        ...params.taskId ? { taskId: params.taskId } : {},
+        ...params.days ? { days: params.days } : {},
+        ...params.global ? { global: params.global } : {}
+      };
+      return lafsSuccess(enrichedData, "compliance.summary");
+    } catch (err) {
+      return lafsError(
+        "E_FILE_ERROR",
+        err instanceof Error ? err.message : String(err),
+        "compliance.summary"
+      );
+    }
+  },
+  test: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (params?.format === "coverage") {
+      try {
+        const result = checkTestCoverage(projectRoot, {});
+        return lafsSuccess(result, "test");
+      } catch (err) {
+        return lafsError("E_FILE_ERROR", err instanceof Error ? err.message : String(err), "test");
+      }
+    }
+    try {
+      const result = checkTestStatus(projectRoot, params);
+      return lafsSuccess(result, "test");
+    } catch (err) {
+      return lafsError("E_GENERAL", err instanceof Error ? err.message : String(err), "test");
+    }
+  },
+  coherence: async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = await checkCoherence(projectRoot, params);
+      return lafsSuccess(result, "coherence");
+    } catch (err) {
+      return lafsError(
+        "E_NOT_INITIALIZED",
+        err instanceof Error ? err.message : String(err),
+        "coherence"
+      );
+    }
+  },
+  protocol: async (params) => {
+    const projectRoot = getProjectRoot();
+    const protocolType = params.protocolType;
+    const mode = params.mode ?? "task";
+    const protocolParams = {
+      mode,
+      taskId: params.taskId,
+      manifestFile: params.manifestFile,
+      strict: params.strict
+    };
+    switch (protocolType) {
+      case "consensus": {
+        const result = await validateProtocolConsensus(projectRoot, {
+          ...protocolParams,
+          votingMatrixFile: params.votingMatrixFile
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "contribution": {
+        const result = await validateProtocolContribution(projectRoot, protocolParams);
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "decomposition": {
+        const result = await validateProtocolDecomposition(projectRoot, {
+          ...protocolParams,
+          epicId: params.epicId
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "implementation": {
+        const result = await validateProtocolImplementation(projectRoot, protocolParams);
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "specification": {
+        const result = await validateProtocolSpecification(projectRoot, {
+          ...protocolParams,
+          specFile: params.specFile
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "research": {
+        const result = await validateProtocolResearch(projectRoot, {
+          ...protocolParams,
+          hasCodeChanges: params.hasCodeChanges
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "architecture-decision":
+      case "architecture_decision": {
+        const result = await validateProtocolArchitectureDecision(projectRoot, {
+          ...protocolParams,
+          adrContent: params.adrContent,
+          status: params.status,
+          hitlReviewed: params.hitlReviewed,
+          downstreamFlagged: params.downstreamFlagged,
+          persistedInDb: params.persistedInDb
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "validation": {
+        const result = await validateProtocolValidation(projectRoot, {
+          ...protocolParams,
+          specMatchConfirmed: params.specMatchConfirmed,
+          testSuitePassed: params.testSuitePassed,
+          protocolComplianceChecked: params.protocolComplianceChecked
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "testing": {
+        const result = await validateProtocolTesting(projectRoot, {
+          ...protocolParams,
+          framework: params.framework,
+          testsRun: params.testsRun,
+          testsPassed: params.testsPassed,
+          testsFailed: params.testsFailed,
+          coveragePercent: params.coveragePercent,
+          coverageThreshold: params.coverageThreshold,
+          ivtLoopConverged: params.ivtLoopConverged,
+          ivtLoopIterations: params.ivtLoopIterations
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "release": {
+        const result = await validateProtocolRelease(projectRoot, {
+          ...protocolParams,
+          version: params.version,
+          hasChangelog: params.hasChangelog
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "artifact-publish":
+      case "artifact_publish": {
+        const result = await validateProtocolArtifactPublish(projectRoot, {
+          ...protocolParams,
+          artifactType: params.artifactType,
+          buildPassed: params.buildPassed
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      case "provenance": {
+        const result = await validateProtocolProvenance(projectRoot, {
+          ...protocolParams,
+          hasAttestation: params.hasAttestation,
+          hasSbom: params.hasSbom
+        });
+        if (!result.success) {
+          return lafsError(
+            String(result.error?.code ?? "E_INTERNAL"),
+            result.error?.message ?? "Unknown error",
+            "protocol"
+          );
+        }
+        return lafsSuccess(result.data ?? { taskId: "", protocol: "", passed: false }, "protocol");
+      }
+      default: {
+        if (!params.taskId) {
+          return lafsError(
+            "E_INVALID_INPUT",
+            "taskId is required for generic protocol check",
+            "protocol"
+          );
+        }
+        try {
+          const result = await checkValidateProtocol(projectRoot, params);
+          return lafsSuccess(result, "protocol");
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          const code = message.includes("not found") ? "E_NOT_FOUND" : "E_INVALID_INPUT";
+          return lafsError(code, message, "protocol");
+        }
+      }
+    }
+  },
+  "gate.status": async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.taskId) {
+      return lafsError("E_INVALID_INPUT", "taskId is required", "gate.status");
+    }
+    const result = await validateGateVerify(projectRoot, { taskId: params.taskId });
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "gate.status"
+      );
+    }
+    return lafsSuccess(
+      result.data ?? { taskId: params.taskId, gates: {}, passed: false },
+      "gate.status"
+    );
+  },
+  // T12308: `cleo verify <id> --run` — execute the task's typed gates and
+  // report them. A query, because it records no verification: the results are
+  // an observation, and only `--evidence` turns an observation into an
+  // attestation (its one write is the T12621 pass cache that attestation
+  // reuses). Restored because the spawn prompt has never stopped telling
+  // agents to run it.
+  "gate.run": async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.taskId) {
+      return lafsError("E_INVALID_INPUT", "taskId is required", "gate.run");
+    }
+    try {
+      const preview = await previewTaskGates(projectRoot, params);
+      return lafsSuccess(preview, "gate.run");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return lafsError(
+        message.includes("not found") ? "E_NOT_FOUND" : "E_INTERNAL",
+        message,
+        "gate.run"
+      );
+    }
+  },
+  "verify.explain": async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.taskId) {
+      return lafsError("E_INVALID_INPUT", "taskId is required", "verify.explain");
+    }
+    const raw = await validateGateVerify(projectRoot, { taskId: params.taskId });
+    if (!raw.success) {
+      return lafsError(
+        String(raw.error?.code ?? "E_INTERNAL"),
+        raw.error?.message ?? "Unknown error",
+        "verify.explain"
+      );
+    }
+    const result = await checkExplainVerification(
+      raw.data,
+      projectRoot,
+      params.taskId
+    );
+    return lafsSuccess(result, "verify.explain");
+  },
+  "archive.stats": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = await checkArchiveStats(projectRoot, params);
+      return lafsSuccess(result, "archive.stats");
+    } catch (err) {
+      return lafsError(
+        "E_NOT_INITIALIZED",
+        err instanceof Error ? err.message : String(err),
+        "archive.stats"
+      );
+    }
+  },
+  grade: async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.sessionId) {
+      return lafsError("E_INVALID_INPUT", "sessionId required", "grade");
+    }
+    try {
+      const gradeResult = await checkGradeSession(projectRoot, params);
+      return lafsSuccess(gradeResult, "grade");
+    } catch (err) {
+      return lafsError("E_NOT_FOUND", err instanceof Error ? err.message : String(err), "grade");
+    }
+  },
+  "grade.list": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = await checkReadGrades(projectRoot, params);
+      return lafsSuccess(result, "grade.list");
+    } catch (err) {
+      return lafsError(
+        "E_NOT_FOUND",
+        err instanceof Error ? err.message : String(err),
+        "grade.list"
+      );
+    }
+  },
+  canon: async (_params) => {
+    const projectRoot = getProjectRoot();
+    const { runCanonCheck } = await import("./canon-NPF5RODM.js");
+    const result = runCanonCheck({ projectRoot });
+    return lafsSuccess(result, "canon");
+  },
+  "canon.docs": async (params) => {
+    const projectRoot = getProjectRoot();
+    const { runCanonDocsCheck } = await import("./canon-docs-2GTOLF7Y.js");
+    try {
+      const result = runCanonDocsCheck({
+        projectRoot,
+        ...params.baseRef !== void 0 ? { baseRef: params.baseRef } : {},
+        ...params.candidateFiles !== void 0 ? { candidateFiles: params.candidateFiles } : {}
+      });
+      if (!result.passed) {
+        const firstFix = result.violations[0]?.fix ?? "cleo docs add ...";
+        const fileList = result.violations.map((v) => `${v.file} (kind=${v.kind})`).join(", ");
+        return lafsError(
+          "E_CANON_VIOLATION",
+          `Docs canon violation: ${result.violations.length} raw *.md addition(s) bypass the SSoT \u2014 ${fileList}`,
+          "canon.docs",
+          `Route through SSoT instead: ${firstFix}`,
+          { result }
+        );
+      }
+      return lafsSuccess(result, "canon.docs");
+    } catch (err) {
+      return lafsError(
+        "E_CANON_INVALID",
+        err instanceof Error ? err.message : String(err),
+        "canon.docs"
+      );
+    }
+  },
+  "workflow.compliance": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = await checkWorkflowCompliance(projectRoot, params);
+      return lafsSuccess(result, "workflow.compliance");
+    } catch (err) {
+      return lafsError(
+        "E_GENERAL",
+        err instanceof Error ? err.message : String(err),
+        "workflow.compliance"
+      );
+    }
+  },
+  // -----------------------------------------------------------------------
+  // Mutate ops
+  // -----------------------------------------------------------------------
+  "compliance.record": async (params) => {
+    const projectRoot = getProjectRoot();
+    if (!params.taskId || !params.result) {
+      return lafsError("E_INVALID_INPUT", "taskId and result are required", "compliance.record");
+    }
+    try {
+      const result = checkComplianceRecord(projectRoot, params);
+      return lafsSuccess(result, "compliance.record");
+    } catch (err) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        err instanceof Error ? err.message : String(err),
+        "compliance.record"
+      );
+    }
+  },
+  "test.run": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = checkTestRun(projectRoot, params);
+      return lafsSuccess(result, "test.run");
+    } catch (err) {
+      return lafsError("E_GENERAL", err instanceof Error ? err.message : String(err), "test.run");
+    }
+  },
+  "test.coverage": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = checkTestCoverage(projectRoot, params ?? {});
+      return lafsSuccess(result, "test.coverage");
+    } catch (err) {
+      return lafsError(
+        "E_FILE_ERROR",
+        err instanceof Error ? err.message : String(err),
+        "test.coverage"
+      );
+    }
+  },
+  "compliance.sync": async (params) => {
+    const projectRoot = getProjectRoot();
+    try {
+      const result = await checkComplianceSync(projectRoot, params);
+      return lafsSuccess(result, "compliance.sync");
+    } catch (err) {
+      return lafsError(
+        "E_GENERAL",
+        err instanceof Error ? err.message : String(err),
+        "compliance.sync"
+      );
+    }
+  },
+  "gate.set": async (params) => {
+    const projectRoot = resolveWorktreeRouting().canonicalRoot;
+    if (!params.taskId) {
+      return lafsError("E_INVALID_INPUT", "taskId is required", "gate.set");
+    }
+    const gateParams = {
+      taskId: params.taskId,
+      gate: params.gate,
+      value: params.value,
+      agent: params.agent,
+      all: params.all,
+      reset: params.reset,
+      evidence: params.evidence,
+      sessionId: params.sessionId,
+      sharedEvidence: params.sharedEvidence,
+      noRun: params.noRun
+    };
+    const result = await validateGateVerify(projectRoot, gateParams);
+    setImmediate(async () => {
+      try {
+        const { trackMemoryUsage } = await import("@cleocode/core/memory/quality-feedback");
+        await trackMemoryUsage(projectRoot, params.taskId, true, params.taskId, "verified");
+      } catch {
+      }
+    });
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "gate.set"
+      );
+    }
+    return lafsSuccess(
+      result.data ?? { taskId: params.taskId, gates: {}, passed: false },
+      "gate.set"
+    );
+  }
+});
+var CheckHandler = class {
+  async query(operation, params) {
+    const startTime = Date.now();
+    try {
+      const envelope = await typedDispatch(
+        _checkTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return {
+        meta: dispatchMeta("query", "check", operation, startTime),
+        success: envelope.success,
+        ...envelope.success ? { data: envelope.data } : {
+          error: {
+            code: envelope.error?.code !== void 0 ? String(envelope.error.code) : "E_INTERNAL",
+            message: envelope.error?.message ?? "Unknown error",
+            ...envelope.error?.fix !== void 0 ? { fix: envelope.error.fix } : {},
+            ...envelope.error?.details !== void 0 ? { details: envelope.error.details } : {}
+          }
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      getLogger("domain:check").error(
+        { gateway: "query", domain: "check", operation, err: error },
+        message
+      );
+      return handleErrorResult("query", "check", operation, error, startTime);
+    }
+  }
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    try {
+      const envelope = await typedDispatch(
+        _checkTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return {
+        meta: dispatchMeta("mutate", "check", operation, startTime),
+        success: envelope.success,
+        ...envelope.success ? { data: envelope.data } : {
+          error: {
+            code: envelope.error?.code !== void 0 ? String(envelope.error.code) : "E_INTERNAL",
+            message: envelope.error?.message ?? "Unknown error"
+          }
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      getLogger("domain:check").error(
+        { gateway: "mutate", domain: "check", operation, err: error },
+        message
+      );
+      return handleErrorResult("mutate", "check", operation, error, startTime);
+    }
+  }
+  getSupportedOperations() {
+    return {
+      query: [
+        "schema",
+        "protocol",
+        "task",
+        "manifest",
+        "output",
+        "compliance.summary",
+        "workflow.compliance",
+        "test",
+        "test.coverage",
+        "coherence",
+        "gate.status",
+        "gate.run",
+        "archive.stats",
+        "grade",
+        "grade.list",
+        "canon",
+        "canon.docs",
+        "verify.explain"
+      ],
+      mutate: ["compliance.record", "compliance.sync", "test.run", "gate.set"]
+    };
+  }
+};
+export {
+  CheckHandler
+};
+//# sourceMappingURL=check-C67YAU7W.js.map