@tea-agent/loop-agent 0.2.1 → 0.4.0

package/dist/worker/task-graph/validate.js

@@ -0,0 +1,188 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { taskSpecSchema } from "../task-spec/schema.js";
+import { acceptanceSpecSchema } from "./acceptance-schema.js";
+import { computeReadyQueue } from "./ready-queue.js";
+import { taskGraphSpecSchema } from "./task-graph-schema.js";
+export async function validateFeatureTaskGraph(featureDir, options = {}) {
+    const errors = [];
+    const acceptance = await loadAcceptanceSpec(featureDir, options, errors);
+    const graph = await loadTaskGraphSpec(featureDir, options, errors);
+    if (!acceptance || !graph) {
+        return result("", acceptance, graph, errors);
+    }
+    checkDuplicateNodeIds(graph, errors);
+    checkAcceptanceTaskRefs(acceptance, graph, errors);
+    checkUnknownDependencies(graph, errors);
+    checkCycles(graph, errors);
+    await checkTaskFiles(featureDir, graph, errors);
+    return result(graph.feature_id, acceptance, graph, errors);
+}
+async function loadAcceptanceSpec(featureDir, options, errors) {
+    const raw = options.acceptanceOverride ??
+        YAML.parse(await readFile(path.join(featureDir, "acceptance.yaml"), "utf-8"));
+    const parsed = acceptanceSpecSchema.safeParse(raw);
+    if (!parsed.success) {
+        errors.push({
+            code: "acceptance-schema-invalid",
+            message: parsed.error.issues.map((issue) => issue.message).join("; "),
+            path: "acceptance.yaml",
+        });
+        return undefined;
+    }
+    return parsed.data;
+}
+async function loadTaskGraphSpec(featureDir, options, errors) {
+    const raw = options.graphOverride ??
+        YAML.parse(await readFile(path.join(featureDir, "tasks", "task-graph.yaml"), "utf-8"));
+    const parsed = taskGraphSpecSchema.safeParse(raw);
+    if (!parsed.success) {
+        errors.push({
+            code: "task-graph-schema-invalid",
+            message: parsed.error.issues.map((issue) => issue.message).join("; "),
+            path: "tasks/task-graph.yaml",
+        });
+        return undefined;
+    }
+    return parsed.data;
+}
+function checkDuplicateNodeIds(graph, errors) {
+    const seen = new Set();
+    for (const node of graph.nodes) {
+        if (seen.has(node.id)) {
+            errors.push({
+                code: "duplicate-node-id",
+                message: `duplicate task graph node id: ${node.id}`,
+                path: `nodes.${node.id}`,
+            });
+        }
+        seen.add(node.id);
+    }
+}
+function checkAcceptanceTaskRefs(acceptance, graph, errors) {
+    const nodeIds = new Set(graph.nodes.map((node) => node.id));
+    for (const item of acceptance.acceptance) {
+        for (const taskRef of item.verification.expected_task_refs) {
+            if (!nodeIds.has(taskRef)) {
+                errors.push({
+                    code: "acceptance-task-ref-missing",
+                    message: `acceptance ${item.id} references missing task ${taskRef}`,
+                    path: `acceptance.${item.id}.verification.expected_task_refs`,
+                });
+            }
+        }
+    }
+}
+function checkUnknownDependencies(graph, errors) {
+    const nodeIds = new Set(graph.nodes.map((node) => node.id));
+    for (const node of graph.nodes) {
+        for (const dependency of node.depends_on) {
+            if (!nodeIds.has(dependency)) {
+                errors.push({
+                    code: "unknown-dependency",
+                    message: `${node.id} depends on unknown task ${dependency}`,
+                    path: `nodes.${node.id}.depends_on`,
+                });
+            }
+        }
+    }
+}
+function checkCycles(graph, errors) {
+    const nodes = new Map(graph.nodes.map((node) => [node.id, node]));
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (nodeId, trail) => {
+        if (visiting.has(nodeId)) {
+            errors.push({
+                code: "cycle-detected",
+                message: `cycle detected: ${[...trail, nodeId].join(" -> ")}`,
+                path: `nodes.${nodeId}.depends_on`,
+            });
+            return;
+        }
+        if (visited.has(nodeId))
+            return;
+        const node = nodes.get(nodeId);
+        if (!node)
+            return;
+        visiting.add(nodeId);
+        for (const dependency of node.depends_on)
+            visit(dependency, [...trail, nodeId]);
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+    };
+    for (const node of graph.nodes)
+        visit(node.id, []);
+}
+async function checkTaskFiles(featureDir, graph, errors) {
+    for (const node of graph.nodes) {
+        const taskPath = path.join(featureDir, "tasks", node.task);
+        if (!(await exists(taskPath))) {
+            errors.push({
+                code: "task-file-missing",
+                message: `task file does not exist: ${node.task}`,
+                path: `nodes.${node.id}.task`,
+            });
+            continue;
+        }
+        const parsedTask = taskSpecSchema.safeParse(YAML.parse(await readFile(taskPath, "utf-8")));
+        if (!parsedTask.success) {
+            errors.push({
+                code: "task-spec-schema-invalid",
+                message: `task file is not a valid TaskSpec: ${node.task}`,
+                path: `nodes.${node.id}.task`,
+            });
+            continue;
+        }
+        const taskSpec = parsedTask.data;
+        if (taskSpec.id !== node.id) {
+            errors.push({
+                code: "task-id-mismatch",
+                message: `graph node ${node.id} points at TaskSpec ${taskSpec.id}`,
+                path: `nodes.${node.id}.id`,
+            });
+        }
+        if (taskSpec.type !== node.type) {
+            errors.push({
+                code: "task-type-mismatch",
+                message: `graph node ${node.id} type ${node.type} differs from TaskSpec ${taskSpec.type}`,
+                path: `nodes.${node.id}.type`,
+            });
+        }
+        if (!sameStringSet(taskSpec.depends_on, node.depends_on)) {
+            errors.push({
+                code: "task-depends-on-mismatch",
+                message: `graph node ${node.id} depends_on differs from TaskSpec`,
+                path: `nodes.${node.id}.depends_on`,
+            });
+        }
+    }
+}
+function result(featureId, acceptance, graph, errors) {
+    return {
+        ok: errors.length === 0,
+        featureId,
+        summary: {
+            acceptanceCount: acceptance?.acceptance.length ?? 0,
+            nodeCount: graph?.nodes.length ?? 0,
+            readyWithoutState: graph ? computeReadyQueue(graph, {}) : [],
+        },
+        errors,
+    };
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sameStringSet(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const rightSet = new Set(right);
+    return left.every((value) => rightSet.has(value));
+}

package/dist/worker/task-spec/complexity-mapping.js

@@ -0,0 +1,8 @@
+const RISK_TO_COMPLEXITY = {
+    low: "small",
+    medium: "medium",
+    high: "large",
+};
+export function mapRiskLevelToComplexity(riskLevel) {
+    return RISK_TO_COMPLEXITY[riskLevel];
+}

package/dist/worker/task-spec/schema.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { verifyModeSchema, verifyPresetSchema, verifyQuotaSchema, } from "../../task/config-types.js";
+export const taskSpecTypeSchema = z.enum([
+    "architecture",
+    "backend-feature",
+    "frontend-feature",
+    "bugfix",
+    "ci-fix",
+    "doc-update",
+    "qa-analysis",
+    "qa-casegen",
+    "qa-testcode",
+    "qa-execute",
+    "qa-failure-analysis",
+    "reviewer-gate",
+    "fix-from-failure",
+]);
+export const taskSpecRiskLevelSchema = z.enum(["low", "medium", "high"]);
+const verifyCommandSchema = z
+    .object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    command: z.string().min(1),
+    required: z.boolean().optional().default(true),
+    timeout_ms: z.number().int().positive().optional(),
+})
+    .strict();
+export const taskSpecSchema = z
+    .object({
+    schema_version: z.literal(1),
+    id: z.string().min(1),
+    feature_id: z.string().min(1),
+    title: z.string().min(1),
+    description: z.string().optional().default(""),
+    repo: z
+        .object({
+        name: z.string().min(1),
+        path_ref: z.string().min(1),
+        default_branch: z.string().min(1).optional(),
+    })
+        .strict(),
+    type: taskSpecTypeSchema,
+    priority: z.enum(["P0", "P1", "P2", "P3"]).optional().default("P2"),
+    risk_level: taskSpecRiskLevelSchema,
+    depends_on: z.array(z.string().min(1)).optional().default([]),
+    source_docs: z
+        .object({
+        requirement: z.string().min(1),
+        acceptance: z.string().min(1),
+        design: z.string().min(1).optional(),
+        test_plan: z.string().min(1).optional(),
+        test_cases: z.string().min(1).optional(),
+    })
+        .strict(),
+    acceptance_refs: z.array(z.string().min(1)).min(1),
+    scope: z
+        .object({
+        goals: z.array(z.string().min(1)).min(1),
+        non_goals: z.array(z.string().min(1)).optional().default([]),
+        assumptions: z.array(z.string().min(1)).optional().default([]),
+        open_questions: z.array(z.string().min(1)).optional().default([]),
+    })
+        .strict(),
+    constraints: z
+        .object({
+        allowed_paths: z.array(z.string().min(1)).optional().default([]),
+        forbidden_paths: z.array(z.string().min(1)).optional().default([]),
+        hard_constraints: z.array(z.string().min(1)).optional().default([]),
+    })
+        .strict(),
+    verify: z
+        .object({
+        preset: verifyPresetSchema,
+        mode: verifyModeSchema,
+        quota: verifyQuotaSchema.optional().default("full"),
+        commands: z.array(verifyCommandSchema).optional().default([]),
+    })
+        .strict(),
+    worker: z
+        .object({
+        execution_mode: z.enum([
+            "dry-run",
+            "generate-only",
+            "generate-validate",
+            "generate-validate-run",
+        ]),
+        max_attempts: z.number().int().positive().optional().default(1),
+        timeout_ms: z.number().int().positive().optional(),
+        require_clean_worktree: z.boolean().optional().default(true),
+        require_human_review: z.boolean().optional().default(true),
+        create_worktree: z.boolean().optional().default(false),
+    })
+        .strict(),
+    loop_agent: z
+        .object({
+        profile_policy: z.literal("mapped"),
+        strict_models: z.boolean().optional().default(true),
+        strict_governance: z.boolean().optional().default(true),
+        no_cursor: z.boolean().optional().default(false),
+        max_concurrent: z.number().int().positive().optional().default(1),
+    })
+        .strict(),
+    outputs: z
+        .object({
+        required: z.array(z.string().min(1)).min(1),
+    })
+        .strict(),
+    failure_policy: z
+        .object({
+        failed_run_promote: z.boolean().optional().default(false),
+        generate_closeout_draft: z.boolean().optional().default(true),
+        create_followup_task: z.boolean().optional().default(true),
+    })
+        .strict(),
+})
+    .strict();

package/dist/worker/task-spec/types.js

@@ -0,0 +1 @@
+export {};

package/dist/worker/task-spec/validate.js

@@ -0,0 +1,352 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { resolveLoopAgentProfile } from "../profile-mapping.js";
+import { mapRiskLevelToComplexity } from "./complexity-mapping.js";
+import { taskSpecSchema } from "./schema.js";
+const CODE_WRITING_TYPES = new Set([
+    "backend-feature",
+    "frontend-feature",
+    "bugfix",
+    "qa-testcode",
+]);
+const VERIFY_OPTIONAL_TYPES = new Set(["qa-analysis", "reviewer-gate"]);
+const QA_TYPES = new Set([
+    "qa-analysis",
+    "qa-casegen",
+    "qa-testcode",
+    "qa-execute",
+    "qa-failure-analysis",
+]);
+export async function validateTaskSpec(input, options = {}) {
+    const schemaResult = taskSpecSchema.safeParse(input);
+    const fallback = fallbackIdentity(input);
+    if (!schemaResult.success) {
+        const errors = schemaResult.error.issues.map((issue) => ({
+            layer: "schema",
+            code: "schema-invalid",
+            message: issue.message,
+            path: issue.path.join("."),
+        }));
+        const failure = firstFailure(errors, "schema-invalid", "TaskSpec schema validation failed");
+        return buildResult({
+            taskId: fallback.taskId,
+            featureId: fallback.featureId,
+            businessProfile: fallback.businessProfile,
+            riskLevel: fallback.riskLevel,
+            checks: {
+                schema: failure,
+                sourceDocs: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                acceptanceRefs: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                dependsOn: "skipped",
+                pathBoundary: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                verifyCommands: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                profileMapping: failureFor("schema-invalid", "Skipped because schema validation failed"),
+            },
+            errors,
+            warnings: [],
+        });
+    }
+    const taskSpec = schemaResult.data;
+    const errors = [];
+    const warnings = [];
+    const sourceDocsCheck = await checkSourceDocs(taskSpec, options, errors);
+    const acceptanceRefsCheck = await checkAcceptanceRefs(taskSpec, options, errors);
+    const dependsOnCheck = await checkDependsOn(taskSpec, options, errors);
+    const pathBoundaryCheck = checkPathBoundaries(taskSpec, errors, warnings);
+    const verifyCommandsCheck = checkVerifyCommands(taskSpec, errors);
+    const profileMapping = resolveLoopAgentProfile(taskSpec);
+    return buildResult({
+        taskId: taskSpec.id,
+        featureId: taskSpec.feature_id,
+        businessProfile: taskSpec.type,
+        riskLevel: taskSpec.risk_level,
+        loopAgentProfilePreview: profileMapping.loopAgentProfile,
+        checks: {
+            schema: "ok",
+            sourceDocs: sourceDocsCheck,
+            acceptanceRefs: acceptanceRefsCheck,
+            dependsOn: dependsOnCheck,
+            pathBoundary: pathBoundaryCheck,
+            verifyCommands: verifyCommandsCheck,
+            profileMapping: "ok",
+        },
+        errors,
+        warnings,
+    });
+}
+function buildResult(input) {
+    const riskLevel = input.riskLevel === "low" ||
+        input.riskLevel === "medium" ||
+        input.riskLevel === "high"
+        ? input.riskLevel
+        : "medium";
+    return {
+        schemaVersion: 1,
+        ok: input.errors.length === 0 && checksAreOk(input.checks),
+        taskId: input.taskId,
+        featureId: input.featureId,
+        businessProfile: input.businessProfile,
+        riskLevel: input.riskLevel,
+        complexityPreview: mapRiskLevelToComplexity(riskLevel),
+        loopAgentProfilePreview: input.loopAgentProfilePreview,
+        checks: input.checks,
+        errors: input.errors,
+        warnings: input.warnings,
+    };
+}
+function checksAreOk(checks) {
+    return Object.values(checks).every((check) => check === "ok" || check === "skipped");
+}
+async function checkSourceDocs(taskSpec, options, errors) {
+    const baseDir = getTaskSpecDir(options);
+    if (!baseDir)
+        return "ok";
+    for (const [key, relativePath] of Object.entries(taskSpec.source_docs)) {
+        if (!relativePath)
+            continue;
+        if (!(await exists(path.resolve(baseDir, relativePath)))) {
+            const error = {
+                layer: "file-existence",
+                code: "source-doc-missing",
+                message: `source_docs.${key} does not exist: ${relativePath}`,
+                path: `source_docs.${key}`,
+            };
+            errors.push(error);
+            return toFailure(error);
+        }
+    }
+    return "ok";
+}
+async function checkAcceptanceRefs(taskSpec, options, errors) {
+    const baseDir = getTaskSpecDir(options);
+    if (!baseDir)
+        return "ok";
+    const acceptancePath = path.resolve(baseDir, taskSpec.source_docs.acceptance);
+    if (!(await exists(acceptancePath))) {
+        const error = {
+            layer: "file-existence",
+            code: "acceptance-source-missing",
+            message: `acceptance source does not exist: ${taskSpec.source_docs.acceptance}`,
+            path: "source_docs.acceptance",
+        };
+        errors.push(error);
+        return toFailure(error);
+    }
+    const parsed = YAML.parse(await readFile(acceptancePath, "utf-8"));
+    const ids = collectStringIds(parsed);
+    for (const acceptanceRef of taskSpec.acceptance_refs) {
+        if (!ids.has(acceptanceRef)) {
+            const error = {
+                layer: "file-existence",
+                code: "acceptance-ref-missing",
+                message: `acceptance ref not found in acceptance source: ${acceptanceRef}`,
+                path: "acceptance_refs",
+            };
+            errors.push(error);
+            return toFailure(error);
+        }
+    }
+    return "ok";
+}
+async function checkDependsOn(taskSpec, options, errors) {
+    if (taskSpec.depends_on.length === 0)
+        return "skipped";
+    const baseDir = getTaskSpecDir(options);
+    if (!baseDir)
+        return "ok";
+    for (const dependency of taskSpec.depends_on) {
+        const dependencyPath = path.resolve(baseDir, `${dependency}.yaml`);
+        if (!(await exists(dependencyPath))) {
+            const error = {
+                layer: "file-existence",
+                code: "depends-on-missing",
+                message: `depends_on task file does not exist: ${dependency}.yaml`,
+                path: "depends_on",
+            };
+            errors.push(error);
+            return toFailure(error);
+        }
+    }
+    return "ok";
+}
+function checkPathBoundaries(taskSpec, errors, warnings) {
+    const start = errors.length;
+    for (const [index, allowedPath] of taskSpec.constraints.allowed_paths.entries()) {
+        if (isBroadAllowedPath(allowedPath)) {
+            errors.push({
+                layer: "path-boundary",
+                code: "broad-allowed-paths",
+                message: `allowed_paths entry is too broad: ${allowedPath}`,
+                path: `constraints.allowed_paths[${index}]`,
+            });
+        }
+        for (const [forbiddenIndex, forbiddenPath] of taskSpec.constraints.forbidden_paths.entries()) {
+            if (patternsOverlap(allowedPath, forbiddenPath)) {
+                errors.push({
+                    layer: "path-boundary",
+                    code: "allowed-forbidden-overlap",
+                    message: `allowed path overlaps forbidden path: ${allowedPath} / ${forbiddenPath}`,
+                    path: `constraints.forbidden_paths[${forbiddenIndex}]`,
+                });
+            }
+        }
+    }
+    if (CODE_WRITING_TYPES.has(taskSpec.type) &&
+        taskSpec.constraints.allowed_paths.length === 0) {
+        errors.push({
+            layer: "path-boundary",
+            code: "code-task-empty-allowed-paths",
+            message: `${taskSpec.type} requires non-empty allowed_paths`,
+            path: "constraints.allowed_paths",
+        });
+    }
+    if (taskSpec.constraints.forbidden_paths.length === 0) {
+        errors.push({
+            layer: "path-boundary",
+            code: "forbidden-paths-empty",
+            message: "TaskSpec requires non-empty forbidden_paths",
+            path: "constraints.forbidden_paths",
+        });
+    }
+    if (QA_TYPES.has(taskSpec.type) && !hasQaBusinessCodeForbiddenPath(taskSpec)) {
+        errors.push({
+            layer: "path-boundary",
+            code: "qa-business-code-not-forbidden",
+            message: "QA tasks must forbid common business code directories",
+            path: "constraints.forbidden_paths",
+        });
+    }
+    const complexity = mapRiskLevelToComplexity(taskSpec.risk_level);
+    if ((complexity === "medium" || complexity === "large") &&
+        taskSpec.constraints.allowed_paths.length === 0) {
+        errors.push({
+            layer: "path-boundary",
+            code: "empty-allowed-paths-for-complexity",
+            message: `${complexity} tasks require non-empty allowed_paths before materialize`,
+            path: "constraints.allowed_paths",
+        });
+    }
+    if (complexity === "small" && taskSpec.constraints.allowed_paths.length === 0) {
+        warnings.push({
+            code: "empty-allowed-paths-path-guard-risk",
+            message: "empty allowed_paths will make non-harness writes fail path guard",
+            path: "constraints.allowed_paths",
+        });
+    }
+    const pathErrors = errors.slice(start).filter((error) => error.layer === "path-boundary");
+    if (pathErrors.length === 0)
+        return "ok";
+    return toFailure(pathErrors[0]);
+}
+function checkVerifyCommands(taskSpec, errors) {
+    if (!VERIFY_OPTIONAL_TYPES.has(taskSpec.type) &&
+        taskSpec.verify.commands.length === 0) {
+        const error = {
+            layer: "file-existence",
+            code: "verify-commands-empty",
+            message: `${taskSpec.type} requires verify.commands`,
+            path: "verify.commands",
+        };
+        errors.push(error);
+        return toFailure(error);
+    }
+    return "ok";
+}
+function getTaskSpecDir(options) {
+    return options.taskSpecPath ? path.dirname(options.taskSpecPath) : undefined;
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function collectStringIds(value, ids = new Set()) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectStringIds(item, ids);
+        return ids;
+    }
+    if (value && typeof value === "object") {
+        for (const [key, child] of Object.entries(value)) {
+            if (key === "id" && typeof child === "string")
+                ids.add(child);
+            collectStringIds(child, ids);
+        }
+    }
+    return ids;
+}
+function isBroadAllowedPath(pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    return normalized === "**" || normalized === "./**" || normalized === ".";
+}
+function probeForPattern(pattern) {
+    return pattern
+        .replace(/\\/g, "/")
+        .replace(/\/\*\*$/, "/_probe_")
+        .replace(/\*\*$/, "_probe_")
+        .replace(/\*/g, "_")
+        .replace(/^\.\//, "");
+}
+function patternsOverlap(left, right) {
+    const leftProbe = probeForPattern(left);
+    const rightProbe = probeForPattern(right);
+    return (pathMatchesPattern(leftProbe, right) ||
+        pathMatchesPattern(rightProbe, left) ||
+        leftProbe === rightProbe);
+}
+function pathMatchesPattern(filePath, pattern) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalizedPattern.endsWith("/**")) {
+        const prefix = normalizedPattern.slice(0, -3);
+        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
+    }
+    if (normalizedPattern.includes("*")) {
+        const escaped = normalizedPattern
+            .split("*")
+            .map((part) => part.replace(/[|\\{}()[\]^$+?.]/g, "\\$&"))
+            .join(".*");
+        return new RegExp(`^${escaped}$`).test(normalizedPath);
+    }
+    return normalizedPath === normalizedPattern;
+}
+function hasQaBusinessCodeForbiddenPath(taskSpec) {
+    return taskSpec.constraints.forbidden_paths.some((forbiddenPath) => {
+        const normalized = forbiddenPath.replace(/\\/g, "/");
+        return (normalized.includes("/src/") ||
+            normalized.includes("src/**") ||
+            normalized.includes("/services/") ||
+            normalized.includes("services/**") ||
+            normalized.includes("/app/") ||
+            normalized.includes("app/**") ||
+            normalized.includes("/apps/"));
+    });
+}
+function fallbackIdentity(input) {
+    const record = input && typeof input === "object" ? input : {};
+    return {
+        taskId: typeof record.id === "string" ? record.id : "",
+        featureId: typeof record.feature_id === "string" ? record.feature_id : "",
+        businessProfile: typeof record.type === "string" ? record.type : "",
+        riskLevel: typeof record.risk_level === "string" ? record.risk_level : "medium",
+    };
+}
+function failureFor(code, message, pathValue) {
+    return { status: "failed", code, message, path: pathValue };
+}
+function firstFailure(errors, code, message) {
+    return errors[0] ? toFailure(errors[0]) : failureFor(code, message);
+}
+function toFailure(error) {
+    return {
+        status: "failed",
+        code: error.code,
+        message: error.message,
+        path: error.path,
+    };
+}