@clue-ai/cli 0.0.3

package/src/public-schema.cjs

@@ -0,0 +1,784 @@
+"use strict";
+const zod_1 = require("zod");
+
+const toolingSchemas = (() => {
+const nonEmptyStringSchema = zod_1.z.string().trim().min(1);
+const clueInitToolTargetSchema = zod_1.z.enum(["codex", "claude_code"]);
+const clueInitToolFrameworkSchema = nonEmptyStringSchema;
+const clueInitToolRequiredSecretSchema = zod_1.z.enum([
+    "CLUE_API_KEY",
+    "AI_PROVIDER_API_KEY",
+]);
+const clueInitToolRequiredSecretsSchema = zod_1.z
+    .array(clueInitToolRequiredSecretSchema)
+    .superRefine((value, context) => {
+    for (const secret of clueInitToolRequiredSecretSchema.options) {
+        if (!value.includes(secret)) {
+            context.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `${secret} is required`,
+            });
+        }
+    }
+})
+    .transform((value) => Array.from(new Set(value)));
+const clueInitToolRequestSchema = zod_1.z.object({
+    target_tool: clueInitToolTargetSchema,
+    project_key: nonEmptyStringSchema,
+    environment: nonEmptyStringSchema,
+    service_key: nonEmptyStringSchema,
+    framework: clueInitToolFrameworkSchema.default("fastapi"),
+    allowed_source_paths: zod_1.z.array(nonEmptyStringSchema).min(1),
+    excluded_source_paths: zod_1.z.array(nonEmptyStringSchema).default([]),
+    ci_workflow_path: nonEmptyStringSchema.default(".github/workflows/clue-semantic-snapshot.yml"),
+});
+const clueInitToolLifecycleInsertionSchema = zod_1.z.object({
+    api_name: zod_1.z.enum([
+        "ClueInit",
+        "ClueIdentify",
+        "ClueSetAccount",
+        "ClueLogout",
+    ]),
+    file_path: nonEmptyStringSchema,
+    confidence: zod_1.z.number().min(0).max(1),
+    reason: nonEmptyStringSchema,
+});
+const clueInitToolReportSchema = zod_1.z.object({
+    target_tool: clueInitToolTargetSchema,
+    ci_workflow_path: nonEmptyStringSchema,
+    ci_workflow_added: zod_1.z.literal(true),
+    required_secrets: clueInitToolRequiredSecretsSchema,
+    lifecycle_insertions: zod_1.z.array(clueInitToolLifecycleInsertionSchema),
+    semantic_generation_timing: zod_1.z.literal("after_merge_ci"),
+    semantic_preview_generated: zod_1.z.literal(false),
+    client_repo_generated_files_committed: zod_1.z.literal(false),
+    clue_track_inserted: zod_1.z.literal(false),
+    clue_dom_tag_inserted: zod_1.z.literal(false),
+    allowed_source_paths: zod_1.z.array(nonEmptyStringSchema),
+    excluded_source_paths: zod_1.z.array(nonEmptyStringSchema),
+    warnings: zod_1.z.array(nonEmptyStringSchema).default([]),
+});
+
+  return {
+    clueInitToolRequestSchema,
+    clueInitToolReportSchema,
+  };
+})();
+
+const semanticSchemas = (() => {
+const nonEmptyStringSchema = zod_1.z.string().trim().min(1);
+const nullableNonEmptyStringSchema = nonEmptyStringSchema.nullable();
+const confidenceSchema = zod_1.z.number().min(0).max(1);
+const snakeSegmentPattern = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
+const effectKeyPattern = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*\.[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
+const semanticFieldPathPattern = /^(target_object_profiles|target_object_catalog|target_object_mappings|routes)\[[a-zA-Z0-9_./:{}-]+\](?:\.[a-z][a-z0-9_]*(?:\[[a-zA-Z0-9_./:{}-]+\])?)+$/;
+const sha256HashPattern = /^sha256:[a-f0-9]{64}$/;
+const actualOutcomeActions = new Set([
+    "completed",
+    "failed",
+    "validation_error",
+    "blocked",
+    "abandoned",
+]);
+const jsonPrimitiveSchema = zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    zod_1.z.null(),
+]);
+const semanticSnapshotEffectKindValues = [
+    "data_create",
+    "data_update",
+    "data_delete",
+    "data_upsert",
+    "data_read",
+    "data_query",
+    "data_import",
+    "data_export",
+    "state_transition",
+    "validation_check",
+    "access_check",
+    "communication_send",
+    "audit_record",
+    "event_emit",
+    "background_task_schedule",
+    "external_service_call",
+    "payment_operation",
+    "ai_inference",
+    "file_process",
+    "cache_change",
+    "system_config_change",
+    "unknown",
+];
+const semanticSnapshotResolutionBasisValues = [
+    "route_contract",
+    "direct_data_mutation",
+    "repository_call",
+    "orm_model_call",
+    "sql_statement",
+    "read_query",
+    "external_sdk_call",
+    "message_publish",
+    "job_enqueue",
+    "file_operation",
+    "validation_logic",
+    "access_control_logic",
+    "ai_inferred_code_behavior",
+    "explicit_semantic_config",
+    "unknown",
+];
+const semanticSnapshotEvidenceStrengthValues = [
+    "weak",
+    "medium",
+    "strong",
+    "unknown",
+];
+const semanticSnapshotSelectedSourceValues = [
+    "deterministic",
+    "ai",
+];
+const targetObjectKeySchema = nonEmptyStringSchema.regex(snakeSegmentPattern, {
+    message: "must be a lowercase snake_case key",
+});
+const operationEffectKeySchema = nonEmptyStringSchema
+    .regex(effectKeyPattern, {
+    message: "must use <target_object_key>.<effect_action> with lowercase snake_case segments",
+})
+    .refine((value) => !value.startsWith("unknown."), {
+    message: "must not fabricate unknown.* operation effect keys",
+})
+    .refine((value) => !actualOutcomeActions.has(value.split(".")[1] ?? ""), {
+    message: "must not use runtime actual outcome terms as effect actions",
+});
+const semanticFieldPathSchema = nonEmptyStringSchema
+    .regex(semanticFieldPathPattern, {
+    message: "must be a mechanically generated semantic snapshot field path",
+})
+    .refine((value) => !value.includes("sha256:"), {
+    message: "must not contain hashes",
+})
+    .refine((value) => !/\.(py|ts|tsx|js|mjs)\b/i.test(value), {
+    message: "must not contain raw source file paths",
+});
+const semanticSnapshotHashSchema = nonEmptyStringSchema.regex(sha256HashPattern, {
+    message: "must be a sha256 hash",
+});
+const semanticSnapshotRepositorySchema = zod_1.z
+    .object({
+    provider: nonEmptyStringSchema,
+    repository_id: nonEmptyStringSchema,
+    owner: nonEmptyStringSchema.optional(),
+    name: nonEmptyStringSchema.optional(),
+    default_branch: nonEmptyStringSchema.optional(),
+    merge_commit: nonEmptyStringSchema,
+    merged_at: zod_1.z.string().datetime({ offset: true }).optional(),
+    pull_request_number: zod_1.z.number().int().positive().nullable().optional(),
+    workflow_run_id: nonEmptyStringSchema.optional(),
+})
+    .strict();
+const semanticSnapshotServiceSchema = zod_1.z
+    .object({
+    service_key: nonEmptyStringSchema,
+    root_path: nullableNonEmptyStringSchema.optional(),
+    framework: nullableNonEmptyStringSchema.optional(),
+    language: nullableNonEmptyStringSchema.optional(),
+})
+    .strict();
+const semanticSnapshotAnalysisSummarySchema = zod_1.z
+    .object({
+    total_routes_scanned: zod_1.z.number().int().nonnegative(),
+    routes_generated: zod_1.z.number().int().nonnegative(),
+    uncertain_routes: zod_1.z.number().int().nonnegative(),
+    failed_routes: zod_1.z.number().int().nonnegative(),
+})
+    .strict();
+const semanticCandidateSchema = zod_1.z
+    .object({
+    label: nonEmptyStringSchema,
+    subject_type: nullableNonEmptyStringSchema.optional(),
+    action_category: nullableNonEmptyStringSchema.optional(),
+    outcome_kind: nullableNonEmptyStringSchema.optional(),
+    value_kind: nullableNonEmptyStringSchema.optional(),
+    confidence: confidenceSchema,
+})
+    .strict();
+const layerEvidenceSchema = zod_1.z
+    .object({
+    data_effects: zod_1.z
+        .array(zod_1.z
+        .object({
+        entity_label: nonEmptyStringSchema,
+        mutation_kind: zod_1.z
+            .enum(["create", "update", "delete", "upsert", "read", "unknown"])
+            .optional(),
+        confidence: confidenceSchema.optional(),
+    })
+        .strict())
+        .default([]),
+    side_effects: zod_1.z
+        .array(zod_1.z
+        .object({
+        side_effect_kind: nonEmptyStringSchema,
+        confidence: confidenceSchema.optional(),
+    })
+        .strict())
+        .default([]),
+    failure_surfaces: zod_1.z.array(nonEmptyStringSchema).default([]),
+    validation_field_paths: zod_1.z.array(nonEmptyStringSchema).default([]),
+    permission_scopes: zod_1.z.array(nonEmptyStringSchema).default([]),
+    component_fingerprints: zod_1.z.array(semanticSnapshotHashSchema).default([]),
+})
+    .strict();
+const defaultLayerEvidence = {
+    data_effects: [],
+    side_effects: [],
+    failure_surfaces: [],
+    validation_field_paths: [],
+    permission_scopes: [],
+    component_fingerprints: [],
+};
+const semanticSnapshotSourceEvidenceRefSchema = zod_1.z
+    .object({
+    id: nonEmptyStringSchema,
+    kind: nonEmptyStringSchema,
+    summary: nonEmptyStringSchema,
+    evidence_strength: zod_1.z.enum(semanticSnapshotEvidenceStrengthValues),
+    source_ref_hash: semanticSnapshotHashSchema,
+    location_hash: semanticSnapshotHashSchema,
+    metadata: zod_1.z.record(zod_1.z.string(), jsonPrimitiveSchema).default({}),
+})
+    .strict();
+const semanticSnapshotAiInferenceEvidenceSchema = zod_1.z
+    .object({
+    id: nonEmptyStringSchema,
+    task: nonEmptyStringSchema,
+    input_source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    output_field_paths: zod_1.z.array(semanticFieldPathSchema).default([]),
+    reasoning_summary: nonEmptyStringSchema,
+    missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+})
+    .strict();
+const semanticSnapshotTargetObjectProfileSchema = zod_1.z
+    .object({
+    id: nonEmptyStringSchema,
+    operation_source_key: nonEmptyStringSchema,
+    operation_effect_key: operationEffectKeySchema,
+    raw_target_object_text: nonEmptyStringSchema,
+    concept: nonEmptyStringSchema,
+    business_role: nonEmptyStringSchema,
+    evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+})
+    .strict();
+const semanticSnapshotTargetObjectCatalogEntrySchema = zod_1.z
+    .object({
+    target_object_key: targetObjectKeySchema,
+    display_name: nonEmptyStringSchema,
+    concept: nonEmptyStringSchema,
+    business_role: nonEmptyStringSchema,
+    aliases: zod_1.z.array(nonEmptyStringSchema).default([]),
+    raw_target_object_profile_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    grouping_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+})
+    .strict();
+const semanticSnapshotTargetObjectMappingSchema = zod_1.z
+    .object({
+    id: nonEmptyStringSchema,
+    operation_source_key: nonEmptyStringSchema,
+    operation_effect_key: operationEffectKeySchema,
+    raw_target_object_profile_ref: nonEmptyStringSchema,
+    target_object_key: targetObjectKeySchema,
+    grouping_evidence_ref: nonEmptyStringSchema,
+    mapping_reason: nonEmptyStringSchema,
+    missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+})
+    .strict();
+const semanticSnapshotOperationEffectSchema = zod_1.z
+    .object({
+    operation_effect_key: operationEffectKeySchema,
+    effect_kind: zod_1.z.enum(semanticSnapshotEffectKindValues),
+    expected_domain_effect: operationEffectKeySchema,
+    target_object_key: targetObjectKeySchema,
+    target_object_profile_ref: nonEmptyStringSchema,
+    target_object_mapping_ref: nonEmptyStringSchema,
+    resolution: zod_1.z
+        .object({
+        basis: zod_1.z.enum(semanticSnapshotResolutionBasisValues),
+        reason: nonEmptyStringSchema,
+    })
+        .strict(),
+    source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+})
+    .strict()
+    .superRefine((effect, ctx) => {
+    const effectPrefix = effect.operation_effect_key.split(".")[0];
+    const expectedPrefix = effect.expected_domain_effect.split(".")[0];
+    if (effectPrefix !== effect.target_object_key) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["operation_effect_key"],
+            message: "prefix must equal target_object_key",
+        });
+    }
+    if (expectedPrefix !== effect.target_object_key) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["expected_domain_effect"],
+            message: "prefix must equal target_object_key",
+        });
+    }
+});
+const semanticSnapshotUnresolvedOperationEffectSchema = zod_1.z
+    .object({
+    id: nonEmptyStringSchema,
+    operation_source_key: nonEmptyStringSchema,
+    reason: nonEmptyStringSchema,
+    source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+})
+    .strict();
+const semanticMeaningCandidateValueSchema = zod_1.z.union([
+    nonEmptyStringSchema,
+    zod_1.z.number(),
+    zod_1.z.boolean(),
+    zod_1.z.null(),
+]);
+const semanticSnapshotSemanticMeaningCandidateSchema = zod_1.z
+    .object({
+    id: nonEmptyStringSchema,
+    field_path: semanticFieldPathSchema,
+    parameter_name: nonEmptyStringSchema,
+    deterministic_candidate: zod_1.z
+        .object({
+        value: semanticMeaningCandidateValueSchema,
+        source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+        missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+    })
+        .strict(),
+    ai_candidate: zod_1.z
+        .object({
+        value: semanticMeaningCandidateValueSchema,
+        source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+        ai_inference_evidence_ref: nonEmptyStringSchema,
+        missing_context: zod_1.z.array(nonEmptyStringSchema).default([]),
+    })
+        .strict(),
+    selected_source: zod_1.z.enum(semanticSnapshotSelectedSourceValues),
+    selection_reason: nonEmptyStringSchema,
+    selection_ai_inference_evidence_ref: nonEmptyStringSchema,
+})
+    .strict();
+const routeSemanticSnapshotEntrySchema = zod_1.z
+    .object({
+    operation_source_key: nonEmptyStringSchema,
+    semantic_snapshot_version: nonEmptyStringSchema.optional(),
+    method: nonEmptyStringSchema.optional(),
+    path_template: nonEmptyStringSchema.optional(),
+    semantics: zod_1.z
+        .object({
+        route_summary: nonEmptyStringSchema,
+        action_candidates: zod_1.z.array(semanticCandidateSchema).default([]),
+        outcome_candidates: zod_1.z.array(semanticCandidateSchema).default([]),
+        value_event_candidates: zod_1.z.array(semanticCandidateSchema).default([]),
+        route_confidence: confidenceSchema,
+    })
+        .strict(),
+    layer_evidence: layerEvidenceSchema.default(defaultLayerEvidence),
+    operation_effects: zod_1.z
+        .array(semanticSnapshotOperationEffectSchema)
+        .default([]),
+    unresolved_operation_effects: zod_1.z
+        .array(semanticSnapshotUnresolvedOperationEffectSchema)
+        .default([]),
+    source_evidence_refs: zod_1.z.array(nonEmptyStringSchema).default([]),
+    confidence_reason: nonEmptyStringSchema,
+})
+    .strict();
+const addDuplicateIssues = (ctx, values, path, label) => {
+    const seen = new Set();
+    values.forEach((value, index) => {
+        if (seen.has(value)) {
+            ctx.addIssue({
+                code: "custom",
+                path: [...path, index],
+                message: `${label} must be unique within one semantic snapshot`,
+            });
+        }
+        seen.add(value);
+    });
+};
+const addMissingRefIssue = (ctx, ref, validRefs, path, label) => {
+    if (!validRefs.has(ref)) {
+        ctx.addIssue({
+            code: "custom",
+            path,
+            message: `${label} must reference an existing snapshot-local id`,
+        });
+    }
+};
+const addMissingFieldPathIssue = (ctx, fieldPath, validFieldPaths, path, label) => {
+    if (!validFieldPaths.has(fieldPath)) {
+        ctx.addIssue({
+            code: "custom",
+            path,
+            message: `${label} must reference an existing semantic snapshot field`,
+        });
+    }
+};
+const semanticSnapshotRequestSchema = zod_1.z
+    .object({
+    project_key: nonEmptyStringSchema,
+    idempotency_key: nonEmptyStringSchema,
+    schema_version: zod_1.z.number().int().positive().default(1),
+    semantic_snapshot_version: nonEmptyStringSchema.optional(),
+    generated_at: zod_1.z.string().datetime({ offset: true }),
+    repository: semanticSnapshotRepositorySchema,
+    service: semanticSnapshotServiceSchema,
+    analysis_summary: semanticSnapshotAnalysisSummarySchema,
+    routes: zod_1.z.array(routeSemanticSnapshotEntrySchema).min(1),
+    target_object_profiles: zod_1.z
+        .array(semanticSnapshotTargetObjectProfileSchema)
+        .default([]),
+    target_object_catalog: zod_1.z
+        .array(semanticSnapshotTargetObjectCatalogEntrySchema)
+        .default([]),
+    target_object_mappings: zod_1.z
+        .array(semanticSnapshotTargetObjectMappingSchema)
+        .default([]),
+    source_evidence_refs: zod_1.z
+        .array(semanticSnapshotSourceEvidenceRefSchema)
+        .default([]),
+    ai_inference_evidence: zod_1.z
+        .array(semanticSnapshotAiInferenceEvidenceSchema)
+        .default([]),
+    semantic_meaning_candidates: zod_1.z
+        .array(semanticSnapshotSemanticMeaningCandidateSchema)
+        .default([]),
+})
+    .strict()
+    .superRefine((snapshot, ctx) => {
+    if (snapshot.schema_version >= 2 && !snapshot.semantic_snapshot_version) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["semantic_snapshot_version"],
+            message: "semantic_snapshot_version is required for schema_version >= 2",
+        });
+    }
+    addDuplicateIssues(ctx, snapshot.target_object_profiles.map((profile) => profile.id), ["target_object_profiles"], "target_object_profiles[].id");
+    addDuplicateIssues(ctx, snapshot.target_object_mappings.map((mapping) => mapping.id), ["target_object_mappings"], "target_object_mappings[].id");
+    addDuplicateIssues(ctx, snapshot.target_object_catalog.map((entry) => entry.target_object_key), ["target_object_catalog"], "target_object_catalog[].target_object_key");
+    addDuplicateIssues(ctx, snapshot.source_evidence_refs.map((entry) => entry.id), ["source_evidence_refs"], "source_evidence_refs[].id");
+    addDuplicateIssues(ctx, snapshot.ai_inference_evidence.map((entry) => entry.id), ["ai_inference_evidence"], "ai_inference_evidence[].id");
+    addDuplicateIssues(ctx, snapshot.semantic_meaning_candidates.map((entry) => entry.id), ["semantic_meaning_candidates"], "semantic_meaning_candidates[].id");
+    const profileRefs = new Set(snapshot.target_object_profiles.map((profile) => profile.id));
+    const profileById = new Map(snapshot.target_object_profiles.map((profile) => [profile.id, profile]));
+    const mappingRefs = new Set(snapshot.target_object_mappings.map((mapping) => mapping.id));
+    const mappingById = new Map(snapshot.target_object_mappings.map((mapping) => [mapping.id, mapping]));
+    const catalogKeys = new Set(snapshot.target_object_catalog.map((entry) => entry.target_object_key));
+    const catalogByKey = new Map(snapshot.target_object_catalog.map((entry) => [
+        entry.target_object_key,
+        entry,
+    ]));
+    const sourceEvidenceRefs = new Set(snapshot.source_evidence_refs.map((entry) => entry.id));
+    const aiInferenceRefs = new Set(snapshot.ai_inference_evidence.map((entry) => entry.id));
+    const validFieldPaths = new Set();
+    snapshot.target_object_profiles.forEach((profile) => {
+        const prefix = `target_object_profiles[${profile.id}]`;
+        for (const field of [
+            "raw_target_object_text",
+            "concept",
+            "business_role",
+            "operation_effect_key",
+        ]) {
+            validFieldPaths.add(`${prefix}.${field}`);
+        }
+    });
+    snapshot.target_object_catalog.forEach((entry) => {
+        const prefix = `target_object_catalog[${entry.target_object_key}]`;
+        for (const field of [
+            "display_name",
+            "concept",
+            "business_role",
+            "aliases",
+            "grouping_evidence_refs",
+        ]) {
+            validFieldPaths.add(`${prefix}.${field}`);
+        }
+    });
+    snapshot.target_object_mappings.forEach((mapping) => {
+        const prefix = `target_object_mappings[${mapping.id}]`;
+        for (const field of [
+            "target_object_key",
+            "mapping_reason",
+            "grouping_evidence_ref",
+        ]) {
+            validFieldPaths.add(`${prefix}.${field}`);
+        }
+    });
+    snapshot.routes.forEach((route) => {
+        for (const effect of route.operation_effects) {
+            const prefix = `routes[${route.operation_source_key}].operation_effects[${effect.operation_effect_key}]`;
+            for (const field of [
+                "effect_kind",
+                "expected_domain_effect",
+                "target_object_key",
+                "target_object_profile_ref",
+                "target_object_mapping_ref",
+                "resolution.basis",
+                "resolution.reason",
+            ]) {
+                validFieldPaths.add(`${prefix}.${field}`);
+            }
+        }
+    });
+    snapshot.routes.forEach((route, routeIndex) => {
+        if (snapshot.schema_version >= 2 && !route.semantic_snapshot_version) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["routes", routeIndex, "semantic_snapshot_version"],
+                message: "routes[].semantic_snapshot_version is required for schema_version >= 2",
+            });
+        }
+        if (snapshot.schema_version >= 2 &&
+            route.semantics.value_event_candidates.length > 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["routes", routeIndex, "semantics", "value_event_candidates"],
+                message: "value_event_candidates is legacy compatibility only and must be empty for schema_version >= 2",
+            });
+        }
+        route.source_evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, ["routes", routeIndex, "source_evidence_refs", refIndex], "routes[].source_evidence_refs[]");
+        });
+        route.operation_effects.forEach((effect, effectIndex) => {
+            if (effect.expected_domain_effect !== effect.operation_effect_key) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [
+                        "routes",
+                        routeIndex,
+                        "operation_effects",
+                        effectIndex,
+                        "expected_domain_effect",
+                    ],
+                    message: "operation_effects[].expected_domain_effect must match operation_effect_key for canonical clue_tools snapshots",
+                });
+            }
+            addMissingRefIssue(ctx, effect.target_object_profile_ref, profileRefs, [
+                "routes",
+                routeIndex,
+                "operation_effects",
+                effectIndex,
+                "target_object_profile_ref",
+            ], "operation_effects[].target_object_profile_ref");
+            addMissingRefIssue(ctx, effect.target_object_mapping_ref, mappingRefs, [
+                "routes",
+                routeIndex,
+                "operation_effects",
+                effectIndex,
+                "target_object_mapping_ref",
+            ], "operation_effects[].target_object_mapping_ref");
+            addMissingRefIssue(ctx, effect.target_object_key, catalogKeys, [
+                "routes",
+                routeIndex,
+                "operation_effects",
+                effectIndex,
+                "target_object_key",
+            ], "operation_effects[].target_object_key");
+            const profile = profileById.get(effect.target_object_profile_ref);
+            if (profile &&
+                (profile.operation_source_key !== route.operation_source_key ||
+                    profile.operation_effect_key !== effect.operation_effect_key)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [
+                        "routes",
+                        routeIndex,
+                        "operation_effects",
+                        effectIndex,
+                        "target_object_profile_ref",
+                    ],
+                    message: "operation_effects[].target_object_profile_ref must reference a profile for the same operation source and effect key",
+                });
+            }
+            const mapping = mappingById.get(effect.target_object_mapping_ref);
+            if (mapping &&
+                (mapping.operation_source_key !== route.operation_source_key ||
+                    mapping.operation_effect_key !== effect.operation_effect_key ||
+                    mapping.raw_target_object_profile_ref !==
+                        effect.target_object_profile_ref ||
+                    mapping.target_object_key !== effect.target_object_key)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [
+                        "routes",
+                        routeIndex,
+                        "operation_effects",
+                        effectIndex,
+                        "target_object_mapping_ref",
+                    ],
+                    message: "operation_effects[].target_object_mapping_ref must reference a mapping for the same source, effect, profile, and target object",
+                });
+            }
+            const catalogEntry = catalogByKey.get(effect.target_object_key);
+            if (catalogEntry &&
+                profile &&
+                !catalogEntry.raw_target_object_profile_refs.includes(profile.id)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [
+                        "routes",
+                        routeIndex,
+                        "operation_effects",
+                        effectIndex,
+                        "target_object_key",
+                    ],
+                    message: "operation_effects[].target_object_key must reference a catalog entry that includes the effect profile",
+                });
+            }
+            effect.source_evidence_refs.forEach((ref, refIndex) => {
+                addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                    "routes",
+                    routeIndex,
+                    "operation_effects",
+                    effectIndex,
+                    "source_evidence_refs",
+                    refIndex,
+                ], "operation_effects[].source_evidence_refs[]");
+            });
+        });
+        route.unresolved_operation_effects.forEach((effect, effectIndex) => {
+            effect.source_evidence_refs.forEach((ref, refIndex) => {
+                addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                    "routes",
+                    routeIndex,
+                    "unresolved_operation_effects",
+                    effectIndex,
+                    "source_evidence_refs",
+                    refIndex,
+                ], "unresolved_operation_effects[].source_evidence_refs[]");
+            });
+        });
+    });
+    snapshot.target_object_profiles.forEach((profile, profileIndex) => {
+        profile.evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, ["target_object_profiles", profileIndex, "evidence_refs", refIndex], "target_object_profiles[].evidence_refs[]");
+        });
+        profile.source_evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                "target_object_profiles",
+                profileIndex,
+                "source_evidence_refs",
+                refIndex,
+            ], "target_object_profiles[].source_evidence_refs[]");
+        });
+    });
+    snapshot.target_object_catalog.forEach((entry, entryIndex) => {
+        entry.raw_target_object_profile_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, profileRefs, [
+                "target_object_catalog",
+                entryIndex,
+                "raw_target_object_profile_refs",
+                refIndex,
+            ], "target_object_catalog[].raw_target_object_profile_refs[]");
+        });
+        entry.grouping_evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                "target_object_catalog",
+                entryIndex,
+                "grouping_evidence_refs",
+                refIndex,
+            ], "target_object_catalog[].grouping_evidence_refs[]");
+        });
+    });
+    snapshot.target_object_mappings.forEach((mapping, mappingIndex) => {
+        addMissingRefIssue(ctx, mapping.raw_target_object_profile_ref, profileRefs, [
+            "target_object_mappings",
+            mappingIndex,
+            "raw_target_object_profile_ref",
+        ], "target_object_mappings[].raw_target_object_profile_ref");
+        addMissingRefIssue(ctx, mapping.target_object_key, catalogKeys, ["target_object_mappings", mappingIndex, "target_object_key"], "target_object_mappings[].target_object_key");
+        addMissingRefIssue(ctx, mapping.grouping_evidence_ref, sourceEvidenceRefs, ["target_object_mappings", mappingIndex, "grouping_evidence_ref"], "target_object_mappings[].grouping_evidence_ref");
+        const profile = profileById.get(mapping.raw_target_object_profile_ref);
+        if (profile &&
+            (profile.operation_source_key !== mapping.operation_source_key ||
+                profile.operation_effect_key !== mapping.operation_effect_key)) {
+            ctx.addIssue({
+                code: "custom",
+                path: [
+                    "target_object_mappings",
+                    mappingIndex,
+                    "raw_target_object_profile_ref",
+                ],
+                message: "target_object_mappings[].raw_target_object_profile_ref must reference a profile for the same operation source and effect key",
+            });
+        }
+    });
+    snapshot.ai_inference_evidence.forEach((entry, entryIndex) => {
+        entry.input_source_evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                "ai_inference_evidence",
+                entryIndex,
+                "input_source_evidence_refs",
+                refIndex,
+            ], "ai_inference_evidence[].input_source_evidence_refs[]");
+        });
+        entry.output_field_paths.forEach((fieldPath, fieldPathIndex) => {
+            addMissingFieldPathIssue(ctx, fieldPath, validFieldPaths, [
+                "ai_inference_evidence",
+                entryIndex,
+                "output_field_paths",
+                fieldPathIndex,
+            ], "ai_inference_evidence[].output_field_paths[]");
+        });
+    });
+    snapshot.semantic_meaning_candidates.forEach((candidate, candidateIndex) => {
+        addMissingFieldPathIssue(ctx, candidate.field_path, validFieldPaths, ["semantic_meaning_candidates", candidateIndex, "field_path"], "semantic_meaning_candidates[].field_path");
+        candidate.deterministic_candidate.source_evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                "semantic_meaning_candidates",
+                candidateIndex,
+                "deterministic_candidate",
+                "source_evidence_refs",
+                refIndex,
+            ], "semantic_meaning_candidates[].deterministic_candidate.source_evidence_refs[]");
+        });
+        candidate.ai_candidate.source_evidence_refs.forEach((ref, refIndex) => {
+            addMissingRefIssue(ctx, ref, sourceEvidenceRefs, [
+                "semantic_meaning_candidates",
+                candidateIndex,
+                "ai_candidate",
+                "source_evidence_refs",
+                refIndex,
+            ], "semantic_meaning_candidates[].ai_candidate.source_evidence_refs[]");
+        });
+        addMissingRefIssue(ctx, candidate.ai_candidate.ai_inference_evidence_ref, aiInferenceRefs, [
+            "semantic_meaning_candidates",
+            candidateIndex,
+            "ai_candidate",
+            "ai_inference_evidence_ref",
+        ], "semantic_meaning_candidates[].ai_candidate.ai_inference_evidence_ref");
+        addMissingRefIssue(ctx, candidate.selection_ai_inference_evidence_ref, aiInferenceRefs, [
+            "semantic_meaning_candidates",
+            candidateIndex,
+            "selection_ai_inference_evidence_ref",
+        ], "semantic_meaning_candidates[].selection_ai_inference_evidence_ref");
+    });
+});
+
+  return {
+    semanticSnapshotRequestSchema,
+  };
+})();
+
+const schemaPackage = {
+  clueInitToolRequestSchema: toolingSchemas.clueInitToolRequestSchema,
+  clueInitToolReportSchema: toolingSchemas.clueInitToolReportSchema,
+  semanticSnapshotRequestSchema: semanticSchemas.semanticSnapshotRequestSchema,
+};
+
+module.exports = schemaPackage;
+module.exports.default = schemaPackage;