@thanh01.pmt/domain-kit 0.5.0 → 0.6.0

package/dist/{conceptEscalator-ltRLtPhf.d.cts → conceptEscalator-DPrs4PwC.d.cts}

@@ -1,4 +1,4 @@
-import { L as LlmClientConfig } from './llmClient-ysPhLjcH.cjs';
+import { L as LlmClientConfig, a as LlmClient } from './llmClient-CX5uUiQ1.cjs';
 import { u as ProjectGraph } from './projectGraphSchema-DnD7orZV.cjs';
 
 /**
@@ -19,6 +19,12 @@ interface ConceptMapping {
     keyword: string;
     depth: 'ulo' | 'cio' | 'sio';
     depth_rationale: string;
+    /**
+     * Who decided `depth`. The regex fallback (comment → ulo, import → sio) has no
+     * pedagogical basis — without this marker a degraded run is indistinguishable
+     * from a considered one, because both write the same field.
+     */
+    depth_source: 'llm' | 'heuristic' | 'override';
     evidence_files: string[];
 }
 interface EscalateOptions {
@@ -31,6 +37,9 @@ interface EscalateOptions {
         depth?: string;
     }>;
     llmConfig?: LlmClientConfig;
+    /** Pre-built client from the calling pipeline — reused so every step of one run
+     *  lands in ONE callLog and the feed can report real provenance. */
+    sharedClient?: LlmClient;
 }
 /**
  * Escalate keywords/api_usage to neutral concepts with ULO/CIO/SIO depth and join evidence files.

package/dist/concepts/index.d.cts

@@ -1,4 +1,4 @@
-import { L as LlmClientConfig } from '../llmClient-ysPhLjcH.cjs';
+import { L as LlmClientConfig } from '../llmClient-CX5uUiQ1.cjs';
 import { K as Keyword } from '../keywordExtractor-BxlGRMHC.cjs';
 import '../cpp-CZUPqJt9.cjs';
 

package/dist/concepts/index.d.ts

@@ -1,4 +1,4 @@
-import { L as LlmClientConfig } from '../llmClient-ysPhLjcH.js';
+import { L as LlmClientConfig } from '../llmClient-CX5uUiQ1.js';
 import { K as Keyword } from '../keywordExtractor-DU5XRN8-.js';
 import '../cpp-CZUPqJt9.js';
 

package/dist/{curriculumFeedSchema-DUFwFyr2.d.ts → curriculumFeedSchema-DYayelAA.d.cts}

@@ -136,6 +136,14 @@ declare const FeedNodeSchema: z.ZodObject<{
         reason?: string | undefined;
     }>, "many">>;
     is_core: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Prerequisite concept ids this node needs that NO node in this feed provides —
+     * i.e. the learner must already know them before starting. Previously these were
+     * silently dropped (knowledge path) or crashed emission (both hybrid paths), so a
+     * course silently lost its entry requirements. Kept on the node so the mapping
+     * "concept X needs prior knowledge Y" survives; a course-level roll-up is derivable.
+     */
+    external_prerequisites: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     depth_context: z.ZodOptional<z.ZodObject<{
         ulo: z.ZodDefault<z.ZodString>;
         cio: z.ZodDefault<z.ZodString>;
@@ -183,6 +191,7 @@ declare const FeedNodeSchema: z.ZodObject<{
     concept_ref: string | null;
     user_visible_deliverable: string;
     is_core: boolean;
+    external_prerequisites: string[];
     introduce_aspect: "new" | "advanced" | "preview" | null;
     depth_variants?: {
         ulo: number;
@@ -243,6 +252,7 @@ declare const FeedNodeSchema: z.ZodObject<{
         reason?: string | undefined;
     }[] | undefined;
     is_core?: boolean | undefined;
+    external_prerequisites?: string[] | undefined;
     depth_context?: {
         ulo?: string | undefined;
         cio?: string | undefined;
@@ -302,20 +312,127 @@ declare const FeedPhaseSchema: z.ZodObject<{
     node_ids: string[];
 }>;
 type FeedPhase = z.infer<typeof FeedPhaseSchema>;
+/**
+ * Machine-readable diagnostic. `warnings` in `source` is the DERIVED text view of
+ * these (every diagnostic whose severity is not 'info'), so there is exactly one
+ * source of truth and the host can gate on `code`/`severity` instead of substring
+ * matching free text — the 2026-09-17 class of incident was a drift that was only
+ * ever a warning string.
+ */
+declare const FeedDiagnosticSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "error"]>;
+    message: z.ZodString;
+    node_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+    node_ids: string[];
+}, {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+    node_ids?: string[] | undefined;
+}>;
+type FeedDiagnostic = z.infer<typeof FeedDiagnosticSchema>;
+/** Which LLM providers actually served this graph, and whether any call fell over. */
+declare const FeedProvenanceSchema: z.ZodObject<{
+    providers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    calls: z.ZodDefault<z.ZodNumber>;
+    failed_calls: z.ZodDefault<z.ZodNumber>;
+    degraded: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    models: string[];
+    providers: string[];
+    calls: number;
+    failed_calls: number;
+    degraded: boolean;
+}, {
+    models?: string[] | undefined;
+    providers?: string[] | undefined;
+    calls?: number | undefined;
+    failed_calls?: number | undefined;
+    degraded?: boolean | undefined;
+}>;
+type FeedProvenance = z.infer<typeof FeedProvenanceSchema>;
 declare const CurriculumFeedSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<2>;
     source: z.ZodObject<{
         graph_type: z.ZodEnum<["project_graph", "knowledge_graph", "hybrid_graph"]>;
+        /** DERIVED from diagnostics — do not write to it directly. */
         warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         hallucination_count: z.ZodDefault<z.ZodNumber>;
+        diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<["info", "warning", "error"]>;
+            message: z.ZodString;
+            node_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids: string[];
+        }, {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids?: string[] | undefined;
+        }>, "many">>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            providers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            calls: z.ZodDefault<z.ZodNumber>;
+            failed_calls: z.ZodDefault<z.ZodNumber>;
+            degraded: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            models: string[];
+            providers: string[];
+            calls: number;
+            failed_calls: number;
+            degraded: boolean;
+        }, {
+            models?: string[] | undefined;
+            providers?: string[] | undefined;
+            calls?: number | undefined;
+            failed_calls?: number | undefined;
+            degraded?: boolean | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings: string[];
         hallucination_count: number;
+        diagnostics: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids: string[];
+        }[];
+        provenance?: {
+            models: string[];
+            providers: string[];
+            calls: number;
+            failed_calls: number;
+            degraded: boolean;
+        } | undefined;
     }, {
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings?: string[] | undefined;
         hallucination_count?: number | undefined;
+        diagnostics?: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids?: string[] | undefined;
+        }[] | undefined;
+        provenance?: {
+            models?: string[] | undefined;
+            providers?: string[] | undefined;
+            calls?: number | undefined;
+            failed_calls?: number | undefined;
+            degraded?: boolean | undefined;
+        } | undefined;
     }>;
     learning_nodes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -417,6 +534,14 @@ declare const CurriculumFeedSchema: z.ZodObject<{
             reason?: string | undefined;
         }>, "many">>;
         is_core: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Prerequisite concept ids this node needs that NO node in this feed provides —
+         * i.e. the learner must already know them before starting. Previously these were
+         * silently dropped (knowledge path) or crashed emission (both hybrid paths), so a
+         * course silently lost its entry requirements. Kept on the node so the mapping
+         * "concept X needs prior knowledge Y" survives; a course-level roll-up is derivable.
+         */
+        external_prerequisites: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         depth_context: z.ZodOptional<z.ZodObject<{
             ulo: z.ZodDefault<z.ZodString>;
             cio: z.ZodDefault<z.ZodString>;
@@ -464,6 +589,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         concept_ref: string | null;
         user_visible_deliverable: string;
         is_core: boolean;
+        external_prerequisites: string[];
         introduce_aspect: "new" | "advanced" | "preview" | null;
         depth_variants?: {
             ulo: number;
@@ -524,6 +650,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
             reason?: string | undefined;
         }[] | undefined;
         is_core?: boolean | undefined;
+        external_prerequisites?: string[] | undefined;
         depth_context?: {
             ulo?: string | undefined;
             cio?: string | undefined;
@@ -587,6 +714,19 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings: string[];
         hallucination_count: number;
+        diagnostics: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids: string[];
+        }[];
+        provenance?: {
+            models: string[];
+            providers: string[];
+            calls: number;
+            failed_calls: number;
+            degraded: boolean;
+        } | undefined;
     };
     schema_version: 2;
     phases: {
@@ -628,6 +768,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         concept_ref: string | null;
         user_visible_deliverable: string;
         is_core: boolean;
+        external_prerequisites: string[];
         introduce_aspect: "new" | "advanced" | "preview" | null;
         depth_variants?: {
             ulo: number;
@@ -663,6 +804,19 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings?: string[] | undefined;
         hallucination_count?: number | undefined;
+        diagnostics?: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids?: string[] | undefined;
+        }[] | undefined;
+        provenance?: {
+            models?: string[] | undefined;
+            providers?: string[] | undefined;
+            calls?: number | undefined;
+            failed_calls?: number | undefined;
+            degraded?: boolean | undefined;
+        } | undefined;
     };
     schema_version: 2;
     learning_nodes: {
@@ -708,6 +862,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
             reason?: string | undefined;
         }[] | undefined;
         is_core?: boolean | undefined;
+        external_prerequisites?: string[] | undefined;
         depth_context?: {
             ulo?: string | undefined;
             cio?: string | undefined;
@@ -742,4 +897,4 @@ type FeedGrouping = z.infer<typeof FeedGroupingSchema>;
 /** Strict pre-save resolution validation — fail-closed, no defaulted-empty graphs. */
 declare function validateCurriculumFeed(feed: unknown): CurriculumFeed;
 
-export { CurriculumFeedSchema as C, FeedKeywordsSchema as F, FeedScaffoldCandidateSchema as a, FeedNodeSchema as b, FeedEdgeSchema as c, FeedGroupingSchema as d, FeedPhaseSchema as e, type FeedPhase as f, type CurriculumFeed as g, type FeedNode as h, type FeedEdge as i, type FeedGrouping as j, validateCurriculumFeed as v };
+export { CurriculumFeedSchema as C, FeedKeywordsSchema as F, FeedScaffoldCandidateSchema as a, FeedNodeSchema as b, FeedEdgeSchema as c, FeedGroupingSchema as d, FeedPhaseSchema as e, type FeedPhase as f, FeedDiagnosticSchema as g, type FeedDiagnostic as h, FeedProvenanceSchema as i, type FeedProvenance as j, type CurriculumFeed as k, type FeedNode as l, type FeedEdge as m, type FeedGrouping as n, validateCurriculumFeed as v };

package/dist/{curriculumFeedSchema-DUFwFyr2.d.cts → curriculumFeedSchema-DYayelAA.d.ts}

@@ -136,6 +136,14 @@ declare const FeedNodeSchema: z.ZodObject<{
         reason?: string | undefined;
     }>, "many">>;
     is_core: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Prerequisite concept ids this node needs that NO node in this feed provides —
+     * i.e. the learner must already know them before starting. Previously these were
+     * silently dropped (knowledge path) or crashed emission (both hybrid paths), so a
+     * course silently lost its entry requirements. Kept on the node so the mapping
+     * "concept X needs prior knowledge Y" survives; a course-level roll-up is derivable.
+     */
+    external_prerequisites: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     depth_context: z.ZodOptional<z.ZodObject<{
         ulo: z.ZodDefault<z.ZodString>;
         cio: z.ZodDefault<z.ZodString>;
@@ -183,6 +191,7 @@ declare const FeedNodeSchema: z.ZodObject<{
     concept_ref: string | null;
     user_visible_deliverable: string;
     is_core: boolean;
+    external_prerequisites: string[];
     introduce_aspect: "new" | "advanced" | "preview" | null;
     depth_variants?: {
         ulo: number;
@@ -243,6 +252,7 @@ declare const FeedNodeSchema: z.ZodObject<{
         reason?: string | undefined;
     }[] | undefined;
     is_core?: boolean | undefined;
+    external_prerequisites?: string[] | undefined;
     depth_context?: {
         ulo?: string | undefined;
         cio?: string | undefined;
@@ -302,20 +312,127 @@ declare const FeedPhaseSchema: z.ZodObject<{
     node_ids: string[];
 }>;
 type FeedPhase = z.infer<typeof FeedPhaseSchema>;
+/**
+ * Machine-readable diagnostic. `warnings` in `source` is the DERIVED text view of
+ * these (every diagnostic whose severity is not 'info'), so there is exactly one
+ * source of truth and the host can gate on `code`/`severity` instead of substring
+ * matching free text — the 2026-09-17 class of incident was a drift that was only
+ * ever a warning string.
+ */
+declare const FeedDiagnosticSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "error"]>;
+    message: z.ZodString;
+    node_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+    node_ids: string[];
+}, {
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+    node_ids?: string[] | undefined;
+}>;
+type FeedDiagnostic = z.infer<typeof FeedDiagnosticSchema>;
+/** Which LLM providers actually served this graph, and whether any call fell over. */
+declare const FeedProvenanceSchema: z.ZodObject<{
+    providers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    calls: z.ZodDefault<z.ZodNumber>;
+    failed_calls: z.ZodDefault<z.ZodNumber>;
+    degraded: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    models: string[];
+    providers: string[];
+    calls: number;
+    failed_calls: number;
+    degraded: boolean;
+}, {
+    models?: string[] | undefined;
+    providers?: string[] | undefined;
+    calls?: number | undefined;
+    failed_calls?: number | undefined;
+    degraded?: boolean | undefined;
+}>;
+type FeedProvenance = z.infer<typeof FeedProvenanceSchema>;
 declare const CurriculumFeedSchema: z.ZodObject<{
     schema_version: z.ZodLiteral<2>;
     source: z.ZodObject<{
         graph_type: z.ZodEnum<["project_graph", "knowledge_graph", "hybrid_graph"]>;
+        /** DERIVED from diagnostics — do not write to it directly. */
         warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         hallucination_count: z.ZodDefault<z.ZodNumber>;
+        diagnostics: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<["info", "warning", "error"]>;
+            message: z.ZodString;
+            node_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids: string[];
+        }, {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids?: string[] | undefined;
+        }>, "many">>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            providers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            models: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            calls: z.ZodDefault<z.ZodNumber>;
+            failed_calls: z.ZodDefault<z.ZodNumber>;
+            degraded: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            models: string[];
+            providers: string[];
+            calls: number;
+            failed_calls: number;
+            degraded: boolean;
+        }, {
+            models?: string[] | undefined;
+            providers?: string[] | undefined;
+            calls?: number | undefined;
+            failed_calls?: number | undefined;
+            degraded?: boolean | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings: string[];
         hallucination_count: number;
+        diagnostics: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids: string[];
+        }[];
+        provenance?: {
+            models: string[];
+            providers: string[];
+            calls: number;
+            failed_calls: number;
+            degraded: boolean;
+        } | undefined;
     }, {
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings?: string[] | undefined;
         hallucination_count?: number | undefined;
+        diagnostics?: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids?: string[] | undefined;
+        }[] | undefined;
+        provenance?: {
+            models?: string[] | undefined;
+            providers?: string[] | undefined;
+            calls?: number | undefined;
+            failed_calls?: number | undefined;
+            degraded?: boolean | undefined;
+        } | undefined;
     }>;
     learning_nodes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -417,6 +534,14 @@ declare const CurriculumFeedSchema: z.ZodObject<{
             reason?: string | undefined;
         }>, "many">>;
         is_core: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Prerequisite concept ids this node needs that NO node in this feed provides —
+         * i.e. the learner must already know them before starting. Previously these were
+         * silently dropped (knowledge path) or crashed emission (both hybrid paths), so a
+         * course silently lost its entry requirements. Kept on the node so the mapping
+         * "concept X needs prior knowledge Y" survives; a course-level roll-up is derivable.
+         */
+        external_prerequisites: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         depth_context: z.ZodOptional<z.ZodObject<{
             ulo: z.ZodDefault<z.ZodString>;
             cio: z.ZodDefault<z.ZodString>;
@@ -464,6 +589,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         concept_ref: string | null;
         user_visible_deliverable: string;
         is_core: boolean;
+        external_prerequisites: string[];
         introduce_aspect: "new" | "advanced" | "preview" | null;
         depth_variants?: {
             ulo: number;
@@ -524,6 +650,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
             reason?: string | undefined;
         }[] | undefined;
         is_core?: boolean | undefined;
+        external_prerequisites?: string[] | undefined;
         depth_context?: {
             ulo?: string | undefined;
             cio?: string | undefined;
@@ -587,6 +714,19 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings: string[];
         hallucination_count: number;
+        diagnostics: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids: string[];
+        }[];
+        provenance?: {
+            models: string[];
+            providers: string[];
+            calls: number;
+            failed_calls: number;
+            degraded: boolean;
+        } | undefined;
     };
     schema_version: 2;
     phases: {
@@ -628,6 +768,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         concept_ref: string | null;
         user_visible_deliverable: string;
         is_core: boolean;
+        external_prerequisites: string[];
         introduce_aspect: "new" | "advanced" | "preview" | null;
         depth_variants?: {
             ulo: number;
@@ -663,6 +804,19 @@ declare const CurriculumFeedSchema: z.ZodObject<{
         graph_type: "knowledge_graph" | "hybrid_graph" | "project_graph";
         warnings?: string[] | undefined;
         hallucination_count?: number | undefined;
+        diagnostics?: {
+            code: string;
+            message: string;
+            severity: "info" | "warning" | "error";
+            node_ids?: string[] | undefined;
+        }[] | undefined;
+        provenance?: {
+            models?: string[] | undefined;
+            providers?: string[] | undefined;
+            calls?: number | undefined;
+            failed_calls?: number | undefined;
+            degraded?: boolean | undefined;
+        } | undefined;
     };
     schema_version: 2;
     learning_nodes: {
@@ -708,6 +862,7 @@ declare const CurriculumFeedSchema: z.ZodObject<{
             reason?: string | undefined;
         }[] | undefined;
         is_core?: boolean | undefined;
+        external_prerequisites?: string[] | undefined;
         depth_context?: {
             ulo?: string | undefined;
             cio?: string | undefined;
@@ -742,4 +897,4 @@ type FeedGrouping = z.infer<typeof FeedGroupingSchema>;
 /** Strict pre-save resolution validation — fail-closed, no defaulted-empty graphs. */
 declare function validateCurriculumFeed(feed: unknown): CurriculumFeed;
 
-export { CurriculumFeedSchema as C, FeedKeywordsSchema as F, FeedScaffoldCandidateSchema as a, FeedNodeSchema as b, FeedEdgeSchema as c, FeedGroupingSchema as d, FeedPhaseSchema as e, type FeedPhase as f, type CurriculumFeed as g, type FeedNode as h, type FeedEdge as i, type FeedGrouping as j, validateCurriculumFeed as v };
+export { CurriculumFeedSchema as C, FeedKeywordsSchema as F, FeedScaffoldCandidateSchema as a, FeedNodeSchema as b, FeedEdgeSchema as c, FeedGroupingSchema as d, FeedPhaseSchema as e, type FeedPhase as f, FeedDiagnosticSchema as g, type FeedDiagnostic as h, FeedProvenanceSchema as i, type FeedProvenance as j, type CurriculumFeed as k, type FeedNode as l, type FeedEdge as m, type FeedGrouping as n, validateCurriculumFeed as v };

package/dist/detector/index.cjs

@@ -130,6 +130,13 @@ function detectInputType(options) {
   };
 }
 
+// src/utils/diacritics.ts
+var COMBINING_MARKS = /[\u0300-\u036f]/g;
+var D_WITH_STROKE = /đ/gi;
+function stripDiacritics(s) {
+  return s.normalize("NFD").replace(COMBINING_MARKS, "").replace(D_WITH_STROKE, "d").toLowerCase();
+}
+
 // src/detector/domainDetector.ts
 var DOMAIN_KEYWORDS = {
   software: [
@@ -574,6 +581,9 @@ function detectSyllabusLanguage(text) {
   }
   return "en";
 }
+function normalizeText(s) {
+  return s.normalize("NFC").toLowerCase();
+}
 function detectDomain(options) {
   const evidence = [];
   const detectedTechStack = [];
@@ -630,15 +640,19 @@ function detectDomain(options) {
       }
     }
   }
-  const textContent = [
+  const textContent = normalizeText([
     options.description || "",
     options.goal || "",
     options.syllabusText || ""
-  ].join(" ").toLowerCase();
+  ].join(" "));
+  const textNoMarks = stripDiacritics(textContent);
   for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
     const cat = domain;
     for (const kw of keywords) {
-      if (textContent.includes(kw.toLowerCase())) {
+      const kwNorm = normalizeText(kw);
+      const kwPlain = stripDiacritics(kw);
+      const matched = textContent.includes(kwNorm) || kwPlain !== kwNorm && textNoMarks.includes(kwPlain);
+      if (matched) {
         scores[cat] += 0.1;
         if (!evidence.some((e) => e.includes(`"${kw}"`))) {
           evidence.push(`Keyword "${kw}" \u2192 ${cat}`);
@@ -677,11 +691,12 @@ function detectDomain(options) {
   }
   if (options.syllabusText) {
     const syllabusLang = detectSyllabusLanguage(options.syllabusText);
-    const syllabusLower = options.syllabusText.toLowerCase();
-    if (syllabusLower.includes("h\xECnh h\u1ECDc") || syllabusLower.includes("\u0111\u1EA1i s\u1ED1") || syllabusLower.includes("geometry") || syllabusLower.includes("algebra") || syllabusLower.includes("\u51E0\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("\u5E7E\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("g\xE9om\xE9trie") || syllabusLower.includes("alg\xE8bre")) {
+    const syllabusLower = normalizeText(options.syllabusText);
+    const syllabusPlain = stripDiacritics(options.syllabusText);
+    if (syllabusLower.includes("h\xECnh h\u1ECDc") || syllabusLower.includes("\u0111\u1EA1i s\u1ED1") || syllabusPlain.includes("hinh hoc") || syllabusPlain.includes("dai so") || syllabusLower.includes("geometry") || syllabusLower.includes("algebra") || syllabusLower.includes("\u51E0\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("\u5E7E\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("g\xE9om\xE9trie") || syllabusLower.includes("alg\xE8bre")) {
       scores.math += 0.5;
       detectedSubject = "Mathematics";
-    } else if (syllabusLower.includes("v\u1EADt l\xFD") || syllabusLower.includes("h\xF3a") || syllabusLower.includes("sinh") || syllabusLower.includes("physics") || syllabusLower.includes("chemistry") || syllabusLower.includes("biology") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("physique") || syllabusLower.includes("chimie")) {
+    } else if (syllabusLower.includes("v\u1EADt l\xFD") || syllabusLower.includes("h\xF3a") || syllabusPlain.includes("vat ly") || syllabusPlain.includes("hoa") || syllabusLower.includes("sinh") || syllabusLower.includes("physics") || syllabusLower.includes("chemistry") || syllabusLower.includes("biology") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("physique") || syllabusLower.includes("chimie")) {
       scores.science += 0.5;
       detectedSubject = "Natural Science";
     } else if (syllabusLower.includes("ti\u1EBFng anh") || syllabusLower.includes("english") || syllabusLower.includes("grammar") || syllabusLower.includes("\u82F1\u8BED") || syllabusLower.includes("\u82F1\u8A9E") || syllabusLower.includes("anglais")) {