@thanh01.pmt/domain-kit 0.6.0 → 0.6.2

package/dist/pipeline/index.cjs

@@ -526,6 +526,17 @@ function extractKeywords(sourceContext, basicAnalysis, repoDir, options) {
   return uniqueKeywords;
 }
 
+// src/utils/llmTransportResult.ts
+function transportResultFrom(provider, model, options) {
+  return {
+    provider,
+    model,
+    framingStripped: !!options?.framingStripped,
+    upstreamError: options?.upstreamError,
+    usage: options?.usage
+  };
+}
+
 // src/utils/llmClient.ts
 function summarizeProvenance(callLog) {
   const providers = [];
@@ -538,6 +549,44 @@ function summarizeProvenance(callLog) {
   }
   return { providers, models, calls: callLog.length, failed_calls: failed, degraded: failed > 0 };
 }
+async function responseJsonCompat(response) {
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    const start = text.indexOf("{");
+    if (start < 0) {
+      throw new LlmClientError(`LLM API returned a non-JSON body: ${text.slice(0, 200)}`);
+    }
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{") depth++;
+      if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          return JSON.parse(text.slice(start, i + 1));
+        }
+      }
+    }
+    throw new LlmClientError(`LLM API returned an unterminated JSON body: ${text.slice(0, 200)}`);
+  }
+}
 var LlmClientError = class extends Error {
   constructor(message, status, cause) {
     super(message);
@@ -546,28 +595,22 @@ var LlmClientError = class extends Error {
     this.name = "LlmClientError";
   }
 };
-function resolveProviderChain(config) {
-  const chain = [];
-  const push = (label, baseUrl, apiKey, model) => {
-    if (apiKey && baseUrl && model && !chain.some((c) => c.baseUrl === baseUrl && c.model === model)) {
-      chain.push({ label, baseUrl, apiKey, model });
-    }
-  };
-  if (config?.apiKey) {
-    push("config", config.baseUrl || "https://api.openai.com/v1", config.apiKey, config.model || "gpt-4o-mini");
-  }
-  push("legacy", process.env.LLM_BASE_URL || process.env.OPENAI_BASE_URL || "", process.env.LLM_API_KEY || process.env.OPENAI_API_KEY || "", process.env.LLM_MODEL || process.env.LLM_TIER_FAST || "");
-  push("dashscope", process.env.DASHSCOPE_BASE_URL || process.env.ALIBABA_BASE_URL || "", process.env.DASHSCOPE_API_KEY || process.env.ALIBABA_API_KEY || "", process.env.DASHSCOPE_MODEL || process.env.DEFAULT_AI_MODEL || "");
-  push("nvidia", "https://integrate.api.nvidia.com/v1", process.env.NVIDIA_API_KEY || "", process.env.NVIDIA_MODEL || "nvidia/nemotron-3-ultra-550b-a55b:free");
-  push("openrouter", "https://openrouter.ai/api/v1", process.env.OPENROUTER_API_KEY || "", process.env.OPENROUTER_MODEL || "nvidia/nemotron-3-ultra-550b-a55b:free");
-  if (process.env.OPENROUTER_MODEL) {
-    const or = chain.find((c) => c.label === "openrouter");
-    if (or) {
-      const rest = chain.filter((c) => c !== or);
-      return [or, ...rest];
-    }
-  }
-  return chain;
+function build9routerProvider(model) {
+  const apiKey = process.env.NINEROUTER_API_KEY;
+  if (!apiKey) return null;
+  const baseUrl = (process.env.NINEROUTER_BASE_URL || "https://ai-router.orchable.app/v1").replace(/^["']|["']$/g, "").trim();
+  const label = "9router";
+  const modelName = (model || process.env.NINEROUTER_MODEL || "laguna-s-2.1").trim();
+  return { label, baseUrl, apiKey, model: modelName };
+}
+function resolve9routerChain(configModel) {
+  const primary = build9routerProvider(configModel);
+  if (!primary) return [];
+  const alt = process.env.NINEROUTER_MODEL_ALT && process.env.NINEROUTER_MODEL_ALT.trim();
+  if (!alt) return [primary];
+  const secondary = build9routerProvider(alt);
+  if (!secondary) return [primary];
+  return primary.model === secondary.model ? [primary] : [primary, secondary];
 }
 var MIN_REQUEST_INTERVAL_MS = 2500;
 var requestIntervalMs = Number(process.env.LLM_MIN_REQUEST_INTERVAL_MS || MIN_REQUEST_INTERVAL_MS);
@@ -578,11 +621,11 @@ async function pacedDelay() {
   lastRequestAt = Date.now();
 }
 function createLlmClient(config) {
-  const chain = resolveProviderChain(config);
+  const chain = resolve9routerChain(config?.model);
   const primary = chain[0];
   if (!primary) {
     throw new LlmClientError(
-      "No LLM provider configured. Set NVIDIA_API_KEY (primary) and/or OPENROUTER_API_KEY (fallback), or pass llmConfig."
+      "No 9router provider configured. Set NINEROUTER_API_KEY and NINEROUTER_MODEL (or the NINEROUTER_* env defaults expected by the kit)."
     );
   }
   primary.apiKey;
@@ -664,17 +707,22 @@ function createLlmClient(config) {
                 signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
               });
               if (!retry.ok) throw err;
-              const retryData = await retry.json();
+              const retryData = await responseJsonCompat(retry);
               const retryContent2 = retryData.choices?.[0]?.message?.content || "";
               if (!retryContent2.trim()) throw err;
               callLog[recIdx] = { ...callLog[recIdx], ok: true };
+              const transport2 = transportResultFrom(provider.label, retryData.model || provider.model, {
+                usage: retryData.usage,
+                framingStripped: true
+              });
               return {
                 content: retryContent2,
                 model: retryData.model || provider.model,
                 provider: provider.label,
                 attempts: attempts.slice(),
                 usage: retryData.usage,
-                finishReason: retryData.choices?.[0]?.finish_reason
+                finishReason: retryData.choices?.[0]?.finish_reason,
+                _transport: transport2
               };
             }
             if (TRANSIENT.has(response.status)) {
@@ -694,21 +742,26 @@ function createLlmClient(config) {
                 })
               });
               if (!retry.ok) throw err;
-              const retryData = await retry.json();
+              const retryData = await responseJsonCompat(retry);
               const retryContent = retryData.choices?.[0]?.message?.content || "";
               callLog[recIdx] = { ...callLog[recIdx], ok: true };
+              const transport2 = transportResultFrom(provider.label, retryData.model || provider.model, {
+                usage: retryData.usage,
+                framingStripped: true
+              });
               return {
                 content: retryContent,
                 model: retryData.model || provider.model,
                 provider: provider.label,
                 attempts: attempts.slice(),
                 usage: retryData.usage,
-                finishReason: retryData.choices?.[0]?.finish_reason
+                finishReason: retryData.choices?.[0]?.finish_reason,
+                _transport: transport2
               };
             }
             throw err;
           }
-          const data = await response.json();
+          const data = await responseJsonCompat(response);
           const wrappedError = data.error;
           if (wrappedError) {
             throw new LlmClientError("[" + provider.label + "] upstream error " + (wrappedError.code ?? "") + ": " + (wrappedError.message ?? "unknown"));
@@ -717,13 +770,18 @@ function createLlmClient(config) {
           if (!content.trim()) {
             throw new LlmClientError("[" + provider.label + "] empty completion returned");
           }
+          const transport = transportResultFrom(provider.label, data.model || provider.model, {
+            usage: data.usage,
+            framingStripped: true
+          });
           return {
             content,
             model: data.model || provider.model,
             provider: provider.label,
             attempts: attempts.slice(),
             usage: data.usage,
-            finishReason: data.choices?.[0]?.finish_reason
+            finishReason: data.choices?.[0]?.finish_reason,
+            _transport: transport
           };
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -897,7 +955,7 @@ async function extractProjectOverview(options) {
       (kw) => `- ${kw.keyword} (from ${kw.source})`
     );
     if (kwItems.length > 0) {
-      keywordsAnchor = "\nAST Domain Keywords & Patterns (from static analysis \u2014 use as context anchor):\n" + kwItems.join("\n") + "\n";
+      keywordsAnchor = "\nDomain Keywords & Patterns (from regex-based static scan \u2014 use as context anchor):\n" + kwItems.join("\n") + "\n";
     }
   }
   const systemPrompt = "You are a software architect. The app the user will build IS EXACTLY the provided files (not an SDK/lib). Analyze them and return a PROJECT OVERVIEW \u2014 meta only, DO NOT list steps (steps are handled in a later step). NEVER invent files/APIs. NEVER reference internal SDK/lib unless it appears in the given files.\nEND-USER VIEW (M1/Design Thinking): product.purpose must describe the USER PROBLEM (what the user does with the app, which need it solves). NEVER describe repo/artifacts.\nDEVELOPMENT STAGES: Include 4-6 development stages in product.development_stages. Each stage must have: stage (name), need (list of feature needs), learn (concepts learned), product_state (what works), temporary_approach, and validation.\nMISSING GAPS: Identify 0-5 missing_gaps (features/functionality that should exist but don't).\nTECH DEBT: Identify 0-5 tech_debt issues (code quality problems).\nALL text must be in ENGLISH.";
@@ -1946,7 +2004,7 @@ async function runProjectGraphPipeline(options) {
   const filePaths = selectedPaths;
   const primaryLang = detectPrimaryLanguage(filePaths);
   log("STEP_1", `Primary language: ${primaryLang}, ${filePaths.length} files loaded (${fileContentsMap.size} with content)`);
-  log("STEP_1", "Parsing source files with AST-level analysis...");
+  log("STEP_1", "Parsing source files with regex-based scan (no AST library)...");
   const allParseResults = [];
   for (const [relPath, content] of fileContentsMap) {
     const fullPath = relPath;
@@ -1970,7 +2028,7 @@ async function runProjectGraphPipeline(options) {
   } else {
     mergedContext = mergeCppResults(allParseResults.filter((r) => "error_handling" in r && !("docstrings" in r) && !("property_wrappers" in r)));
   }
-  log("STEP_2", "Extracting keywords from AST analysis...");
+  log("STEP_2", "Extracting keywords from regex-based source scan...");
   const astKeywords = extractKeywords(mergedContext);
   log("STEP_2", `Extracted ${astKeywords.length} keywords`);
   log("STEP_3", "Building SDK API index...");
@@ -2710,7 +2768,110 @@ function techSignalHits(text) {
   }
   return hits;
 }
-function auditDepthLayers(concepts) {
+var COMPLETABLE_VERBS = [
+  "build",
+  "create",
+  "implement",
+  "write",
+  "configure",
+  "add",
+  "use",
+  "apply",
+  "display",
+  "store",
+  "load",
+  "save",
+  "handle",
+  "parse",
+  "validate",
+  "test",
+  "register",
+  "compute",
+  "generate",
+  "print",
+  "format",
+  "convert",
+  "extend",
+  "define",
+  "execute",
+  "run",
+  "read",
+  "fetch",
+  "wrap",
+  "log",
+  "call",
+  "raise",
+  "install",
+  "import",
+  "export",
+  "declare",
+  "embed",
+  "model",
+  "represent",
+  "override",
+  "customize",
+  "enforce",
+  "mock",
+  "assert",
+  "query",
+  "index",
+  "cache",
+  "stream",
+  "split",
+  "join",
+  "strip",
+  "encode",
+  "decode",
+  "traverse",
+  "measure",
+  "evaluate",
+  "benchmark",
+  "diagnose",
+  "demonstrate",
+  "verify",
+  "organize",
+  "structure",
+  "choose",
+  "select",
+  "compare",
+  "distinguish",
+  "attach",
+  "annotate",
+  "expose",
+  "accept",
+  "manage",
+  "group",
+  "sort",
+  "filter",
+  "map",
+  "reduce",
+  "catch",
+  "throw",
+  "migrate",
+  "inspect",
+  "trace",
+  "parameterize",
+  "construct",
+  "design",
+  "capture",
+  // Completable implementation verbs present in production SIO output but
+  // missing from the original registry (2026-10-07 smoke test, swift kg):
+  "update",
+  "inject",
+  "compose",
+  "pass",
+  "modify",
+  "connect",
+  "remove",
+  "transform",
+  "trigger",
+  "refresh",
+  "persist",
+  "observe",
+  "arrange",
+  "derive"
+];
+function auditDepthLayers(concepts, transport) {
   return concepts.map((c) => {
     const ulo = (c.ulo ?? "").trim();
     const cio = (c.cio ?? "").trim();
@@ -2731,7 +2892,7 @@ function auditDepthLayers(concepts) {
     });
     const conceptKeywords = (c.keywords ?? []).map((k) => k.toLowerCase()).filter(Boolean);
     const sioOffConceptItems = conceptKeywords.length > 0 ? sioItems.filter((s) => !boundToConcept(s)) : [];
-    const COMPLETABLE = /\b(build|create|implement|write|configure|add|use|apply|display|store|load|save|handle|parse|validate|test|register|compute|generate|print|format|convert|extend|define|execute|run|read|fetch|wrap|log|call|raise|install|import|export|declare|embed|model|represent|override|customize|enforce|mock|assert|query|index|cache|stream|split|join|strip|encode|decode|traverse|measure|evaluate|benchmark|diagnose|demonstrate|verify|organize|structure|choose|select|compare|distinguish|attach|annotate|expose|accept|manage|group|sort|filter|map|reduce|catch|throw|migrate|inspect|trace|parameterize|construct|design|capture)\b/i;
+    const COMPLETABLE = new RegExp("\\b(?:" + COMPLETABLE_VERBS.join("|") + ")\\b", "i");
     const sioNotCompletable = sioItems.filter((s) => !COMPLETABLE.test(s) && !/`[^`]+`/.test(s));
     const density = (text) => {
       if (!text) return 0;
@@ -2771,7 +2932,8 @@ function auditDepthLayers(concepts) {
       clauseOk,
       codesOk,
       codeIssues,
-      passed
+      passed,
+      transport
     };
   });
 }
@@ -2781,14 +2943,14 @@ function excerpt(text, max) {
   const t = (text || "").trim();
   return t.length > max ? t.slice(0, max) + "..." : t;
 }
-async function chatJson(client, system, user) {
+async function chatJson(client, system, user, transport) {
   const r = await client.chat(
     [{ role: "system", content: system }, { role: "user", content: user }],
     { temperature: 0.1, maxTokens: parseInt(process.env.KG_MAX_TOKENS || "65536", 10) }
   );
   return parseJsonFromLlm(r.content);
 }
-var LO_BATCH_SIZE = 6;
+var LO_BATCH_SIZE = 10;
 function chunkConcepts(items, size) {
   const out = [];
   for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
@@ -2827,7 +2989,7 @@ async function authorDepthLayersHierarchically(client, concepts, techStack, warn
   for (const batch of chunkConcepts(concepts, LO_BATCH_SIZE)) {
     const batchList = batch.map((c) => "- " + c.id + " (" + c.name + ")" + (c.description ? ": " + excerpt(c.description, 160) : "")).join("\n");
     const batchUser = "Concepts:\n" + batchList + '\n\nReturn JSON:\n{"ulos":[{"concept_id":"C1","ulo":"..."}]}';
-    const uloRes = await chatJson(client, uloSystem, batchUser);
+    const uloRes = await chatJson(client, uloSystem, batchUser, transportResultFrom("9router", client.model, { framingStripped: true }));
     for (const u of uloRes.ulos ?? []) {
       if (u.concept_id && u.ulo) uloByConcept[u.concept_id] = standardStatement(u.ulo);
     }
@@ -2866,7 +3028,7 @@ async function authorDepthLayersHierarchically(client, concepts, techStack, warn
     new Set(batch.map((c) => c.id));
     const batchUloContext = batch.map((c) => "- " + c.id + " (" + c.name + "): " + (uloByConcept[c.id] || "(missing)")).join("\n");
     const batchCioUser = "Approved ULOs:\n" + batchUloContext + '\n\nReturn JSON:\n{"cios":[{"concept_id":"C1","cio":"..."}]}';
-    const cioRes = await chatJson(client, cioSystem, batchCioUser);
+    const cioRes = await chatJson(client, cioSystem, batchCioUser, transportResultFrom("9router", client.model, { framingStripped: true }));
     for (const x of cioRes.cios ?? []) {
       if (x.concept_id && x.cio) cioByConcept[x.concept_id] = standardStatement(x.cio);
     }
@@ -2891,15 +3053,7 @@ async function authorDepthLayersHierarchically(client, concepts, techStack, warn
     "   context where it is used. Application/Analysis/Creation skills are assessed",
     "   INDIRECTLY through completing these tasks \u2014 there is no fixed Bloom ceiling.",
     "   MACHINE CHECK: every item MUST contain at least one ACTION VERB from this whitelist",
-    "   (build, create, implement, write, configure, add, use, apply, display, store, load,",
-    "   save, handle, parse, validate, test, register, compute, generate, print, format,",
-    "   convert, extend, define, execute, run, read, fetch, wrap, log, call, raise, install,",
-    "   import, export, declare, embed, model, represent, override, customize, enforce, mock,",
-    "   assert, query, index, cache, stream, split, join, strip, encode, decode, traverse,",
-    "   measure, evaluate, benchmark, diagnose, demonstrate, verify, organize, structure,",
-    "   choose, select, compare, distinguish, attach, annotate, expose, accept, manage, group,",
-    "   sort, filter, map, reduce, catch, throw, migrate, inspect, trace, parameterize,",
-    "   construct, design, capture) \u2014 OR wrap the concrete construct in backticks.",
+    "   (" + COMPLETABLE_VERBS.join(", ") + ") \u2014 OR wrap the concrete construct in backticks.",
     "   Items with abstract verbs (understand, learn, know, grasp, appreciate, explore) and",
     "   no backtick construct FAIL the audit. Prefer starting the task phrase with the verb.",
     "3. 2-3 items per concept, each referencing a DIFFERENT concrete construct.",
@@ -2927,7 +3081,7 @@ async function authorDepthLayersHierarchically(client, concepts, techStack, warn
       "Return JSON:",
       '{"sios":[{"concept_id":"C1","sio":["...","..."]}]}'
     ].join("\n");
-    const sioRes = await chatJson(client, sioSystem, batchSioUser);
+    const sioRes = await chatJson(client, sioSystem, batchSioUser, transportResultFrom("9router", client.model, { framingStripped: true }));
     for (const x of sioRes.sios ?? []) {
       if (x.concept_id && Array.isArray(x.sio)) sioByConcept[x.concept_id] = x.sio.map((item) => standardStatement(String(item)));
     }
@@ -2980,7 +3134,7 @@ async function authorDepthLayersHierarchically(client, concepts, techStack, warn
         "- CIO: HOW mechanism, technology-agnostic, more concrete than ULO, Marr 2-Language neutral.",
         "- SIO: keyword-bound completable implementation tasks naming real constructs of " + techStack + ".",
         "- BINDING RULE: every SIO item must contain at least one of the concept's listed keywords VERBATIM (copy the exact keyword text into the sentence).",
-        "- COMPLETABILITY RULE: every SIO item must contain an actionable verb (build, create, implement, write, configure, parse, validate, handle, store, load, run, read, fetch, display, generate, format, convert, test, debug, trace, measure, design, structure, select, filter, sort, map, reduce, catch, throw, migrate, deploy, query, index, cache, stream, inspect) or wrap a concrete construct in backticks \u2014 abstract verbs (understand, learn, know, grasp, explore, appreciate) always fail.",
+        "- COMPLETABILITY RULE: every SIO item must contain an actionable verb (" + ["build", "create", "update", "inject", "compose", "pass", "modify", "use"].join(", ") + " ...full registry in the SIO authoring step) or wrap a concrete construct in backticks \u2014 abstract verbs (understand, learn, know, grasp, explore, appreciate) always fail.",
         "",
         JSON_ONLY
       ].join("\n");
@@ -3028,7 +3182,7 @@ async function authorDepthLayersHierarchically(client, concepts, techStack, warn
       "Depth-layer contract audit failed after repair for: " + detail + " \u2014 regenerate or fix the prompt contract (fail-closed, no silent fallback)"
     );
   }
-  return { uloByConcept, cioByConcept, sioByConcept, audits, warnings };
+  return { uloByConcept, cioByConcept, sioByConcept, audits, warnings, lastTransport: audits[0]?.transport };
 }
 function cell(v) {
   return (v || "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -3171,7 +3325,7 @@ async function standardizeConcepts(opts) {
     "     Adopt the tree's terminology. Only propose new when the tree genuinely has NO concept teaching that knowledge (broader AND narrower both fail).",
     '  2. "proposed_new" - no tree concept covers it at the same granularity. Propose an UPPER_SNAKE_CASE code (descriptive, stable, max 5 words) and a one-sentence definition.',
     "     If between 1 and 3 tree concepts are CLOSE but not exact, list their codes in possible_tree_matches for human review.",
-    `For a "standardized" decision ALSO return "adopted_keywords": the subset of that tree concept's keywords (from the shortlist) that make sense for the course TECH STACK. Drop keywords that name tooling from other ecosystems (e.g. JS test runners for a Python course) \u2014 keep conceptual keywords even when spelled generically. Maximum 8, ordered most-relevant first.`,
+    `For a "standardized" decision ALSO return "adopted_keywords": copy VERBATIM from that tree concept's keyword list in the shortlist (exact tokens, do not re-spell, singularize or translate). Pick the subset that makes sense for the course TECH STACK; if none fit, return an EMPTY array \u2014 never invent a keyword. Maximum 8, ordered most-relevant first.`,
     "Rules:",
     "- Judge by MEANING (definition + keywords), not by string similarity.",
     '- COVERAGE RULE: a "standardized" match must cover ALL primary dimensions of the input concept \u2014 every distinct aspect named in its title or description. A tree concept covering only ONE of several aspects (e.g. "interpreting error messages" for a concept about error handling AND user experience) is a PARTIAL match: decide "proposed_new" and list that tree code in possible_tree_matches.',
@@ -3211,10 +3365,25 @@ async function standardizeConcepts(opts) {
       const tc = catalog.concepts.find((x) => x.code === d.tree_code);
       if (!tc) throw new Error("Concept " + c.id + " standardized to unknown tree code " + d.tree_code + " \u2014 fail-closed");
       const treeKw = new Set(tc.keywords.map((k) => k.toLowerCase()));
-      const adopted = (d.adopted_keywords || []).map((k) => String(k)).filter((k) => {
-        if (treeKw.has(k.toLowerCase())) return true;
-        throw new Error("Concept " + c.id + ' adopted keyword "' + k + '" not in tree concept ' + tc.code + " \u2014 fail-closed");
-      });
+      const rawAdopted = (d.adopted_keywords || []).map((k) => String(k)).filter(Boolean);
+      let adopted;
+      if (tc.keywords.length === 0) {
+        adopted = rawAdopted.filter((k) => (c.keywords ?? []).some((ck) => ck.toLowerCase() === k.toLowerCase()));
+        if (adopted.length === 0) adopted = (c.keywords ?? []).slice(0, 8);
+        warnings.push("Concept " + c.id + ": tree concept " + tc.code + " has no keyword registry \u2014 adopted " + adopted.length + " keyword(s) from the analysis concept");
+      } else {
+        const norm = (k) => k.toLowerCase().replace(/ies$/, "y").replace(/s$/, "");
+        const treeKwNorm = new Set([...treeKw].map(norm));
+        const dropped = [];
+        adopted = rawAdopted.filter((k) => {
+          if (treeKw.has(k.toLowerCase()) || treeKwNorm.has(norm(k))) return true;
+          dropped.push(k);
+          return false;
+        });
+        if (dropped.length > 0) {
+          warnings.push("Concept " + c.id + ": dropped " + dropped.length + " adopted keyword(s) not in tree concept " + tc.code + " registry: " + dropped.join(", "));
+        }
+      }
       if (tc.keywords.length > 0 && adopted.length === 0) {
         throw new Error("Concept " + c.id + " standardized to " + tc.code + " without adopted_keywords \u2014 fail-closed");
       }
@@ -3309,7 +3478,7 @@ async function generateKnowledgeGraph(options) {
     log("STEP_1", `Parsed syllabus: ${parsedSyllabus.units.length} units, ${parsedSyllabus.allTopics.length} topics`);
   }
   const client = createLlmClient(llmConfig);
-  const maxSyllabusChars = parseInt(process.env.KG_MAX_SYLLABUS_CHARS || "16000", 10);
+  const maxSyllabusChars = parseInt(process.env.KG_MAX_SYLLABUS_CHARS || "32000", 10);
   let truncatedSyllabus = "";
   if (syllabusText) {
     if (syllabusText.length > maxSyllabusChars) {
@@ -3499,23 +3668,32 @@ Return JSON:
       }
     }
     const idByTreeCode = new Map(concepts.filter((c) => c.tree_code).map((c) => [c.tree_code, c.id]));
+    const unmappedTreePrereqs = /* @__PURE__ */ new Set();
     for (const c of concepts) {
       for (const tp of c.tree_prerequisites || []) {
         const target = idByTreeCode.get(tp);
         if (target && target !== c.id && !(c.prerequisites || []).includes(target)) {
           c.prerequisites = [...c.prerequisites || [], target];
           warnings.push("Prereq seeded from tree: " + c.id + " <- " + tp + " (" + target + ")");
+        } else if (!target) {
+          unmappedTreePrereqs.add(tp);
         }
       }
     }
+    if (unmappedTreePrereqs.size > 0) {
+      const shown = [...unmappedTreePrereqs].slice(0, 10).join(", ");
+      warnings.push("Tree prereqs outside THIS analysis (no edge seeded, " + unmappedTreePrereqs.size + " codes): " + shown + (unmappedTreePrereqs.size > 10 ? ", ..." : ""));
+    }
     log("STEP_2_5", "Standardized: " + std.decisions.filter((d) => d.decision === "standardized").length + ", proposed new: " + std.decisions.filter((d) => d.decision === "proposed_new").length);
+  } else {
+    warnings.push("No knowledgeTreePath provided \u2014 concepts are NOT standardized against the knowledge tree (all proposed_new)");
   }
   log("STEP_3", "Checking for prerequisite cycles...");
   const cycles = detectPrerequisiteCycles(concepts);
   if (cycles.length > 0) {
     log("STEP_3", `Found ${cycles.length} cycle(s) in prerequisite chain \u2014 breaking cycles`);
     for (const cycle of cycles) {
-      warnings.push(`Cycle detected: ${cycle.join(" \u2192 ")} \u2014 breaking at weakest edge`);
+      warnings.push(`Cycle detected: ${cycle.join(" \u2192 ")} \u2014 removing the closing back-edge (last DFS edge; pedagogically arbitrary)`);
     }
     const { fixed, removed } = breakPrerequisiteCycles(concepts, cycles);
     for (let i = 0; i < concepts.length; i++) {
@@ -4432,6 +4610,15 @@ function emitCurriculumFeed(graph, opts = {}) {
   return emitFromProject(g, opts);
 }
 
+// src/pipeline/emitFeed.ts
+function emitNormalizedFeed(req) {
+  return emitCurriculumFeed(req.graph, {
+    warnings: req.warnings,
+    hallucinationCount: req.hallucinationCount,
+    provenance: req.provenance ? summarizeProvenance(req.provenance) : void 0
+  });
+}
+
 // src/pipeline/knowledgeGraphPipeline.ts
 async function runKnowledgeGraphPipeline(options) {
   const warnings = [];
@@ -4452,9 +4639,10 @@ async function runKnowledgeGraphPipeline(options) {
     parsedSyllabus
   });
   warnings.push(...result.warnings);
-  const curriculumFeed = emitCurriculumFeed(result.knowledgeGraph, {
+  const curriculumFeed = emitNormalizedFeed({
+    graph: result.knowledgeGraph,
     warnings,
-    provenance: summarizeProvenance(result.provenance)
+    provenance: result.provenance
   });
   return {
     knowledgeGraph: result.knowledgeGraph,
@@ -4770,9 +4958,10 @@ async function runHybridGraphPipeline(options) {
   const warnings = [];
   const result = await generateHybridGraph(options);
   warnings.push(...result.warnings);
-  const curriculumFeed = emitCurriculumFeed(result.hybridGraph, {
+  const curriculumFeed = emitNormalizedFeed({
+    graph: result.hybridGraph,
     warnings,
-    provenance: summarizeProvenance(result.provenance)
+    provenance: result.provenance
   });
   return {
     hybridGraph: result.hybridGraph,
@@ -5651,6 +5840,7 @@ function detectDomainProfile(options) {
       learningMode: modeResult.confidence
     },
     evidence: [...inputResult.evidence, ...domainResult.evidence, ...modeResult.evidence],
+    ambiguous: domainResult.ambiguous,
     detectedTechStack: domainResult.detectedTechStack,
     detectedSubject: options.parsedSyllabus?.subject.title || domainResult.detectedSubject,
     detectedDomain: domainResult.domainCategory,
@@ -5718,7 +5908,7 @@ async function runDomainPipeline(options) {
       const projectResult2 = await runProjectGraphPipeline({
         repoDir: options.repoDir,
         goal: options.goal || "Build complete project",
-        techStack: options.techStack || "typescript",
+        techStack: options.techStack || domainProfile.detectedTechStack?.[0] || "typescript",
         llmConfig: options.llmConfig,
         embeddings: options.embeddings,
         onProgress: options.onProgress
@@ -5728,8 +5918,9 @@ async function runDomainPipeline(options) {
         description: options.description,
         syllabusText: options.syllabusText,
         parsedSyllabus: options.parsedSyllabus,
+        gradeBand: options.gradeBand,
         domain: domainProfile.domainCategory,
-        techStack: options.techStack,
+        techStack: options.techStack || domainProfile.detectedTechStack?.[0],
         llmConfig: options.llmConfig,
         onProgress: options.onProgress,
         knowledgeTreePath: options.knowledgeTreePath,
@@ -5759,8 +5950,9 @@ async function runDomainPipeline(options) {
         description: options.description,
         syllabusText: options.syllabusText,
         parsedSyllabus: options.parsedSyllabus,
+        gradeBand: options.gradeBand,
         domain: domainProfile.domainCategory,
-        techStack: options.techStack,
+        techStack: options.techStack || domainProfile.detectedTechStack?.[0],
         llmConfig: options.llmConfig,
         onProgress: options.onProgress,
         knowledgeTreePath: options.knowledgeTreePath,
@@ -5789,10 +5981,11 @@ async function runDomainPipeline(options) {
     embeddings: options.embeddings,
     onProgress: options.onProgress
   });
-  const curriculumFeed = emitCurriculumFeed(projectResult.projectGraph, {
+  const curriculumFeed = emitNormalizedFeed({
+    graph: projectResult.projectGraph,
     warnings,
     hallucinationCount: projectResult.hallucinations.length,
-    provenance: summarizeProvenance(projectResult.provenance)
+    provenance: projectResult.provenance
   });
   return {
     domainProfile,