@thanh01.pmt/domain-kit 0.5.0 → 0.6.0

package/dist/pipeline/index.d.cts

@@ -1,13 +1,13 @@
 import { u as ProjectGraph } from '../projectGraphSchema-DnD7orZV.cjs';
 import { K as Keyword } from '../keywordExtractor-BxlGRMHC.cjs';
-import { H as Hallucination, K as KnowledgeGraphPipelineOptions, f as KnowledgeGraphVerificationReport, j as HybridGraphPipelineOptions } from '../hybridGraphPipeline-dT-bio-3.cjs';
-import { C as ConceptMapping } from '../conceptEscalator-ltRLtPhf.cjs';
+import { H as Hallucination, K as KnowledgeGraphPipelineOptions, f as KnowledgeGraphVerificationReport, j as HybridGraphPipelineOptions } from '../hybridGraphPipeline-CocfYe4d.cjs';
+import { C as ConceptMapping } from '../conceptEscalator-DPrs4PwC.cjs';
 import { ResolveConceptsResult } from '../concepts/index.cjs';
 import { AssembledRoadmap } from '../assembly/index.cjs';
-import { L as LlmClientConfig } from '../llmClient-ysPhLjcH.cjs';
+import { L as LlmClientConfig, b as LlmCallRecord } from '../llmClient-CX5uUiQ1.cjs';
 import { P as ParsedSyllabus } from '../syllabusParser-MSX1fEzW.cjs';
-import { g as KnowledgeGraph, j as HybridGraph } from '../hybridGraphSchema-nrUeSwpU.cjs';
-import { g as CurriculumFeed } from '../curriculumFeedSchema-DUFwFyr2.cjs';
+import { g as KnowledgeGraph, j as HybridGraph } from '../hybridGraphSchema-C37qxdTM.cjs';
+import { k as CurriculumFeed } from '../curriculumFeedSchema-DYayelAA.cjs';
 import { D as DetectDomainProfileOptions } from '../domainProfileDetector-bzugdQmS.cjs';
 import { c as DomainProfile, g as GraphType } from '../domainProfileSchema-CwT3Ffsw.cjs';
 import 'zod';
@@ -41,6 +41,8 @@ interface PipelineResult {
     hallucinations: Hallucination[];
     keywords: Keyword[];
     featureConcepts: Map<string, ConceptMapping[]>;
+    /** Which providers served this graph, and whether any call fell over. */
+    provenance: LlmCallRecord[];
 }
 /**
  * Run the full project graph generation pipeline.
@@ -119,6 +121,12 @@ interface DomainPipelineResult {
     knowledgeResult?: KnowledgePipelineResult;
     hybridResult?: HybridPipelineResult;
     warnings: string[];
+    /** Present only when the AUTO-detected learning mode could not run and the router ran a weaker pipeline instead. An explicit forcedLearningMode request fails closed instead of downgrading. */
+    modeDowngrade?: {
+        from: GraphType;
+        to: GraphType;
+        reason: string;
+    };
 }
 /**
  * Route and execute the appropriate domain pipeline based on input context.

package/dist/pipeline/index.d.ts

@@ -1,13 +1,13 @@
 import { u as ProjectGraph } from '../projectGraphSchema-DnD7orZV.js';
 import { K as Keyword } from '../keywordExtractor-DU5XRN8-.js';
-import { H as Hallucination, K as KnowledgeGraphPipelineOptions, f as KnowledgeGraphVerificationReport, j as HybridGraphPipelineOptions } from '../hybridGraphPipeline-DXQDbBEj.js';
-import { C as ConceptMapping } from '../conceptEscalator-YfMKIKCZ.js';
+import { H as Hallucination, K as KnowledgeGraphPipelineOptions, f as KnowledgeGraphVerificationReport, j as HybridGraphPipelineOptions } from '../hybridGraphPipeline-9dRKJj7r.js';
+import { C as ConceptMapping } from '../conceptEscalator-BCsw0ys_.js';
 import { ResolveConceptsResult } from '../concepts/index.js';
 import { AssembledRoadmap } from '../assembly/index.js';
-import { L as LlmClientConfig } from '../llmClient-ysPhLjcH.js';
+import { L as LlmClientConfig, b as LlmCallRecord } from '../llmClient-CX5uUiQ1.js';
 import { P as ParsedSyllabus } from '../syllabusParser-MSX1fEzW.js';
-import { g as KnowledgeGraph, j as HybridGraph } from '../hybridGraphSchema-nrUeSwpU.js';
-import { g as CurriculumFeed } from '../curriculumFeedSchema-DUFwFyr2.js';
+import { g as KnowledgeGraph, j as HybridGraph } from '../hybridGraphSchema-C37qxdTM.js';
+import { k as CurriculumFeed } from '../curriculumFeedSchema-DYayelAA.js';
 import { D as DetectDomainProfileOptions } from '../domainProfileDetector-DHb1T0zB.js';
 import { c as DomainProfile, g as GraphType } from '../domainProfileSchema-CwT3Ffsw.js';
 import 'zod';
@@ -41,6 +41,8 @@ interface PipelineResult {
     hallucinations: Hallucination[];
     keywords: Keyword[];
     featureConcepts: Map<string, ConceptMapping[]>;
+    /** Which providers served this graph, and whether any call fell over. */
+    provenance: LlmCallRecord[];
 }
 /**
  * Run the full project graph generation pipeline.
@@ -119,6 +121,12 @@ interface DomainPipelineResult {
     knowledgeResult?: KnowledgePipelineResult;
     hybridResult?: HybridPipelineResult;
     warnings: string[];
+    /** Present only when the AUTO-detected learning mode could not run and the router ran a weaker pipeline instead. An explicit forcedLearningMode request fails closed instead of downgrading. */
+    modeDowngrade?: {
+        from: GraphType;
+        to: GraphType;
+        reason: string;
+    };
 }
 /**
  * Route and execute the appropriate domain pipeline based on input context.

package/dist/pipeline/index.mjs

@@ -1,11 +1,12 @@
-export { runDomainPipeline, runHybridGraphPipeline, runKnowledgeGraphPipeline, runProjectGraphPipeline } from '../chunk-G7HLFMD2.mjs';
-import '../chunk-TWKIVUTQ.mjs';
-import '../chunk-E4GCCWJO.mjs';
+export { runDomainPipeline, runHybridGraphPipeline, runKnowledgeGraphPipeline, runProjectGraphPipeline } from '../chunk-5OMSYKQP.mjs';
+import '../chunk-WKTH3JPA.mjs';
+import '../chunk-CGNXGVHV.mjs';
 import '../chunk-DRVOV5ZD.mjs';
 import '../chunk-XMHKWHVK.mjs';
-import '../chunk-BL5NBKPH.mjs';
-import '../chunk-TYXSJUQU.mjs';
+import '../chunk-67GXK3ZE.mjs';
+import '../chunk-2OGNQUXC.mjs';
 import '../chunk-T4Y2DE2W.mjs';
+import '../chunk-OYSZQVPY.mjs';
 import '../chunk-KNDBODUQ.mjs';
 import '../chunk-ONQHJ4OH.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/schemas/index.cjs

@@ -477,9 +477,27 @@ var HybridGraphSchema = zod.z.object({
   phases: zod.z.array(DevelopmentPhaseSchema).optional().default([]),
   // Metadata
   description: zod.z.string().optional().default(""),
+  // ── Minute totals (HG-1, 2026-10-05) ────────────────────────────────────
+  // These three used to sit side by side with near-identical names and NO
+  // documentation. Two measured DIFFERENT quantities, which is why the field
+  // below was renamed: it does not measure "the total". Read before trusting
+  // any of them.
+  /** Minutes of PRODUCT work: sum over every feature step. */
   total_project_minutes: zod.z.number().optional().default(0),
+  /** Minutes of CONCEPT work: sum over EVERY concept in the graph. */
   total_concept_minutes: zod.z.number().optional().default(0),
-  estimated_total_minutes: zod.z.number().optional().default(0)
+  /**
+   * Renamed from `estimated_total_minutes` (2026-10-05) — the old name read
+   * like "the course total" but the number is narrower:
+   *   total_project_minutes + (minutes of concepts that HAVE a feature link)
+   * unlinked concepts are deliberately excluded, and per concept the MAXIMUM
+   * link estimate wins, not the sum. Expect this to sit well BELOW
+   * total_project_minutes + total_concept_minutes.
+   *
+   * The figure the phase planner actually commits to is
+   * total_project_minutes + total_concept_minutes (see decomposePhases).
+   */
+  linked_prereq_minutes: zod.z.number().optional().default(0)
 });
 var InputTypeSchema = zod.z.enum([
   "repository",
@@ -606,6 +624,14 @@ var FeedNodeSchema = zod.z.object({
     reason: zod.z.string().default("")
   })).optional(),
   is_core: zod.z.boolean().default(false),
+  /**
+   * 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: zod.z.array(zod.z.string()).default([]),
   // Depth layer text (optional, additive — old feeds validate unchanged).
   // Carries the ULO/CIO/SIO authored text from the KnowledgeGraph concept
   // so downstream consumers (KX generator) can inject depth-appropriate
@@ -641,12 +667,28 @@ var FeedPhaseSchema = zod.z.object({
   product_completion: zod.z.string().min(1),
   node_ids: zod.z.array(zod.z.string()).min(1)
 });
+var FeedDiagnosticSchema = zod.z.object({
+  code: zod.z.string().min(1),
+  severity: zod.z.enum(["info", "warning", "error"]),
+  message: zod.z.string(),
+  node_ids: zod.z.array(zod.z.string()).default([])
+});
+var FeedProvenanceSchema = zod.z.object({
+  providers: zod.z.array(zod.z.string()).default([]),
+  models: zod.z.array(zod.z.string()).default([]),
+  calls: zod.z.number().int().nonnegative().default(0),
+  failed_calls: zod.z.number().int().nonnegative().default(0),
+  degraded: zod.z.boolean().default(false)
+});
 var CurriculumFeedSchema = zod.z.object({
   schema_version: zod.z.literal(2),
   source: zod.z.object({
     graph_type: zod.z.enum(["project_graph", "knowledge_graph", "hybrid_graph"]),
+    /** DERIVED from diagnostics — do not write to it directly. */
     warnings: zod.z.array(zod.z.string()).default([]),
-    hallucination_count: zod.z.number().int().nonnegative().default(0)
+    hallucination_count: zod.z.number().int().nonnegative().default(0),
+    diagnostics: zod.z.array(FeedDiagnosticSchema).default([]),
+    provenance: FeedProvenanceSchema.optional()
   }),
   learning_nodes: zod.z.array(FeedNodeSchema).min(1, "curriculum feed must contain at least one learning node"),
   dependency_edges: zod.z.array(FeedEdgeSchema).default([]),
@@ -679,6 +721,15 @@ function validateCurriculumFeed(feed) {
   }
   const phaseIds = parsed.phases.map((p) => p.id);
   if (new Set(phaseIds).size !== phaseIds.length) throw new Error("curriculum feed contains duplicate phase ids");
+  const phaseOrders = parsed.phases.map((p) => p.order);
+  if (new Set(phaseOrders).size !== phaseOrders.length) {
+    throw new Error("curriculum feed contains duplicate phase orders: " + phaseOrders.join(", "));
+  }
+  for (let i = 1; i < phaseOrders.length; i++) {
+    if (phaseOrders[i] <= phaseOrders[i - 1]) {
+      throw new Error("curriculum feed phase orders are not ascending: " + phaseOrders.join(", "));
+    }
+  }
   if (parsed.phases.length > 0) {
     const phaseIndexOf = /* @__PURE__ */ new Map();
     parsed.phases.forEach((p, i) => {
@@ -717,11 +768,13 @@ exports.ExperienceComponentSchema = ExperienceComponentSchema;
 exports.ExperienceSchema = ExperienceSchema;
 exports.ExperimentProcedureSchema = ExperimentProcedureSchema;
 exports.FeatureSchema = FeatureSchema;
+exports.FeedDiagnosticSchema = FeedDiagnosticSchema;
 exports.FeedEdgeSchema = FeedEdgeSchema;
 exports.FeedGroupingSchema = FeedGroupingSchema;
 exports.FeedKeywordsSchema = FeedKeywordsSchema;
 exports.FeedNodeSchema = FeedNodeSchema;
 exports.FeedPhaseSchema = FeedPhaseSchema;
+exports.FeedProvenanceSchema = FeedProvenanceSchema;
 exports.FeedScaffoldCandidateSchema = FeedScaffoldCandidateSchema;
 exports.GrammarRuleSchema = GrammarRuleSchema;
 exports.GraphTypeSchema = GraphTypeSchema;