@thanh01.pmt/curriculum-kit 1.0.0

package/dist/standards/index.cjs

@@ -0,0 +1,910 @@
+'use strict';
+
+var zod = require('zod');
+var supabaseJs = require('@supabase/supabase-js');
+
+// src/standards/frameworkPackSchema.ts
+var BloomHintSchema = zod.z.object({
+  process: zod.z.enum(["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"]).describe("Cognitive process axis"),
+  knowledge: zod.z.enum(["FACTUAL", "CONCEPTUAL", "PROCEDURAL", "METACOGNITIVE"]).optional().describe("Knowledge dimension axis (optional \u2014 most source standards do not tag it)")
+});
+var RecordProvenanceSchema = zod.z.object({
+  method: zod.z.enum(["source_official", "ai_draft", "minted_from_content", "human", "crosswalk", "imported"]).describe("source_official = copied from an authoritative machine-readable source; ai_draft = LLM-extracted, REQUIRES human review before activation; minted_from_content = ID synthesized because source has none; crosswalk = derived by the curriculum-crosswalk skill"),
+  reviewedBy: zod.z.string().optional().describe("Person/agent that approved this record (required for ai_draft records before activation)"),
+  reviewedAt: zod.z.string().optional().describe("ISO-8601 timestamp of review"),
+  note: zod.z.string().optional().describe("Free-form provenance note")
+});
+var GradeBandSchema = zod.z.array(zod.z.number().int().min(-1).max(30), { message: "gradeBand must be [minGrade, maxGrade] integers" }).length(2).refine(([min, max]) => min <= max, { message: "gradeBand min must be <= max" }).describe("Canonical numeric grade band. -1 = kindergarten/pre-primary. Framework-specific models (VN grades, US bands, ages) normalize into this scale via manifest.gradeModel");
+var ClassificationSchema = zod.z.object({
+  axis: zod.z.string().describe('Axis label, e.g. "strand", "dimension", "Ch\u1EE7 \u0111\u1EC1"'),
+  value: zod.z.string().describe('Value on that axis, e.g. "AP", "Disciplinary Core Idea", "Thu\u1EADt to\xE1n"')
+});
+var FrameworkPackManifestSchema = zod.z.object({
+  /** Immutable pack identifier. Never reused, never renamed. */
+  id: zod.z.string().min(3).regex(/^[a-z0-9][a-z0-9._-]*$/, "pack id must be kebab/lowercase-safe (a-z 0-9 . _ -)").describe('Immutable pack identifier, e.g. "csta-k12-2017", "gdpt-2018-tin-hoc", "abc-tin-hoc"'),
+  name: zod.z.string().min(1).describe("Human-readable framework name"),
+  specVersion: zod.z.literal("1.0").describe("Version of THIS pack contract (not the content)"),
+  contentVersion: zod.z.string().min(1).describe("Content version of the framework inside this pack. Bump on any content change; published versions are immutable"),
+  subject: zod.z.string().describe('Primary subject domain, e.g. "computing", "science", "mathematics"'),
+  languages: zod.z.array(zod.z.string().min(2)).min(1).describe('BCP-47 language codes present in statement texts, e.g. ["vi"], ["en","vi"]'),
+  gradeModel: zod.z.object({
+    type: zod.z.enum(["grades", "ages", "bands"]).describe("grades = school grades (canonical numbers); ages = years old; bands = named developmental bands"),
+    range: GradeBandSchema.describe("Overall grade range covered by the framework"),
+    /** Optional normalization table when type != "grades" (e.g. band "6-8" -> [6,8]). */
+    normalization: zod.z.array(
+      zod.z.object({
+        from: zod.z.string().describe('Source label, e.g. "level 6-8" or "11-13 years"'),
+        to: GradeBandSchema
+      })
+    ).optional().describe('Explicit label -> numeric band conversion table. Required when type != "grades"')
+  }),
+  provenance: zod.z.object({
+    sourceRef: zod.z.string().describe('Citation of the official source, e.g. "Th\xF4ng t\u01B0 32/2018/TT-BGD\u0110T" or a URL'),
+    sourceUrl: zod.z.string().optional().describe("Canonical URL of the source document or live registry"),
+    license: zod.z.string().describe("License / usage rights of the source text"),
+    importedBy: zod.z.string().describe('Who produced this pack, e.g. "platform" or "org:abc"'),
+    importedAt: zod.z.string().describe("ISO-8601 timestamp"),
+    originalFileHash: zod.z.string().optional().describe("SHA-256 of the original uploaded file, for source provenance")
+  }),
+  trust: zod.z.enum(["verified", "org"]).default("org").describe("verified = platform-curated; org = self-served by an org. Generation accepts both; compliance reporting counts verified only")
+});
+var FrameworkStatementSchema = zod.z.object({
+  /** Canonical, forever-stable statement ID (see invariant I3). */
+  id: zod.z.string().min(2).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "statement id must not contain whitespace or separators beyond . _ : -").describe('Statement ID. Official source ID when present (e.g. "1B-AP-10"); otherwise minted once from content identity. Namespaced at query time by the pack id, never stored with prefix duplication'),
+  /** Optional hierarchical parent within the SAME pack (GDPT competence → requirement, CSTA strand → statement, ...). */
+  parentId: zod.z.string().optional().describe("Parent statement id within this pack, when the source framework is hierarchical"),
+  gradeBand: GradeBandSchema,
+  /** Verbatim canonical text per language. The FIRST / primary language text is judge ground truth (invariant I2). */
+  texts: zod.z.record(zod.z.string().min(2), zod.z.string().min(1)).refine((t) => Object.keys(t).length > 0, { message: "texts must contain at least one language entry" }).describe('Verbatim statement text per BCP-47 language key, e.g. {"vi": "Y\xEAu c\u1EA7u c\u1EA7n \u0111\u1EA1t..."}. NEVER paraphrase into these fields'),
+  classifications: zod.z.array(ClassificationSchema).optional().default([]).describe("Optional taxonomy axes from the source framework (strands, dimensions, themes...)"),
+  bloomHint: BloomHintSchema.optional().describe("Optional Bloom dual-axis hint \u2014 a HINT for generation, never a binding claim about the source"),
+  keywords: zod.z.array(zod.z.string()).optional().default([]).describe("Retrieval keywords (topic terms). Used by standards retrieval AND by crosswalk theme matching \u2014 keep them dense"),
+  sourceRef: zod.z.string().optional().describe('Precise citation within the source, e.g. "Trang 24, M\xF4n Tin h\u1ECDc l\u1EDBp 6"'),
+  provenance: RecordProvenanceSchema
+});
+var MappingKindSchema = zod.z.enum(["covers", "partial", "extends"]).describe('covers = the statement is fully taught when the concept is covered (ONLY "covers" counts toward compliance coverage); partial = overlaps partially; extends = statement goes beyond the concept');
+var FrameworkMappingSchema = zod.z.object({
+  statementId: zod.z.string().describe("Must reference a statement id in this pack"),
+  /** Namespaced target. Grammar: <namespace>:<ID>. e.g. "ontora:WHILE_LOOP", "ontora:PROBLEM_DECOMPOSITION". Resolved against the target registry at intake — unknown targets FAIL validation. */
+  targetRef: zod.z.string().refine((v) => /^[a-z][a-z0-9]*:[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v), 'targetRef must be "<namespace>:<ID>", e.g. "ontora:FOR_LOOP"'),
+  kind: MappingKindSchema,
+  confidence: zod.z.number().min(0).max(1).describe("0-1 confidence of this mapping"),
+  provenance: RecordProvenanceSchema
+});
+var FrameworkPackSchema = zod.z.object({
+  manifest: FrameworkPackManifestSchema,
+  statements: zod.z.array(FrameworkStatementSchema).min(1).describe("Atomized statements of the framework"),
+  mappings: zod.z.array(FrameworkMappingSchema).optional().default([]).describe("Optional bridges to the Ontora knowledge tree (statement-only packs are fully functional)")
+});
+var DUP_OVERLAP_RATIO = 0.8;
+function lintFrameworkPack(pack) {
+  const issues = [];
+  const statements = pack.statements;
+  const ids = /* @__PURE__ */ new Set();
+  for (const s of statements) {
+    if (ids.has(s.id)) {
+      issues.push({ severity: "ERROR", code: "DUP_ID", message: `Duplicate statement id "${s.id}"`, ref: s.id });
+    }
+    ids.add(s.id);
+  }
+  for (const s of statements) {
+    if (s.parentId && !ids.has(s.parentId)) {
+      issues.push({ severity: "ERROR", code: "PARENT_MISSING", message: `parentId "${s.parentId}" does not exist in this pack`, ref: s.id });
+    }
+    for (const [lang, text] of Object.entries(s.texts)) {
+      if (!text || text.trim().length < 8) {
+        issues.push({ severity: "ERROR", code: "TEXT_TOO_SHORT", message: `"${lang}" text is empty or shorter than 8 characters`, ref: s.id });
+      }
+    }
+    const [min, max] = s.gradeBand;
+    const [gMin, gMax] = pack.manifest.gradeModel.range;
+    if (min < gMin || max > gMax) {
+      issues.push({ severity: "WARNING", code: "BAND_OUT_OF_RANGE", message: `gradeBand [${min},${max}] falls outside manifest range [${gMin},${gMax}]`, ref: s.id });
+    }
+    if (s.provenance.method === "ai_draft" && !s.provenance.reviewedBy) {
+      issues.push({ severity: "ERROR", code: "AI_DRAFT_UNREVIEWED", message: "ai_draft record has no reviewedBy \u2014 human review required before activation", ref: s.id });
+    }
+    if (!s.keywords || s.keywords.length === 0) {
+      issues.push({ severity: "WARNING", code: "NO_KEYWORDS", message: "No keywords \u2014 statement will be hard to retrieve and to crosswalk", ref: s.id });
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const s of statements) {
+    const primaryLang = pack.manifest.languages[0];
+    const text = s.texts[primaryLang];
+    if (!text) continue;
+    const norm = text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 2).sort().join(" ");
+    if (!norm) continue;
+    const prev = seen.get(norm);
+    if (prev !== void 0) {
+      issues.push({ severity: "WARNING", code: "DUP_TEXT_EXACT", message: `Text is token-identical to statement "${prev}"`, ref: s.id });
+    } else {
+      for (const [otherNorm, otherId] of seen.entries()) {
+        const a = new Set(norm.split(" "));
+        const b = new Set(otherNorm.split(" "));
+        let inter = 0;
+        for (const w of a) if (b.has(w)) inter++;
+        const ratio = inter / Math.max(a.size, b.size);
+        if (ratio >= DUP_OVERLAP_RATIO) {
+          issues.push({ severity: "WARNING", code: "DUP_TEXT_FUZZY", message: `Text ~${Math.round(ratio * 100)}% overlapping with statement "${otherId}"`, ref: s.id });
+          break;
+        }
+      }
+      seen.set(norm, s.id);
+    }
+  }
+  for (const m of pack.mappings ?? []) {
+    if (!ids.has(m.statementId)) {
+      issues.push({ severity: "ERROR", code: "MAP_STATEMENT_MISSING", message: `mapping references unknown statementId "${m.statementId}"`, ref: m.statementId });
+    }
+    if (m.provenance.method === "ai_draft" && !m.provenance.reviewedBy) {
+      issues.push({ severity: "ERROR", code: "AI_DRAFT_UNREVIEWED", message: `mapping to ${m.targetRef} is ai_draft without reviewedBy`, ref: m.statementId });
+    }
+    if (m.kind === "covers" && m.confidence < 0.5) {
+      issues.push({ severity: "WARNING", code: "COVERS_LOW_CONFIDENCE", message: `kind="covers" with confidence ${m.confidence} < 0.5 \u2014 consider "partial"`, ref: m.statementId });
+    }
+  }
+  return issues;
+}
+function validateFrameworkPack(input) {
+  const parsed = FrameworkPackSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      schemaErrors: parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`),
+      lint: [],
+      stats: { statements: 0, mappings: 0, coveredStatements: 0, statementOnlyStatements: 0, gradeRange: [0, 0] }
+    };
+  }
+  const pack = parsed.data;
+  const lint = lintFrameworkPack(pack);
+  const covered = new Set((pack.mappings ?? []).map((m) => m.statementId));
+  const bands = pack.statements.map((s) => s.gradeBand);
+  return {
+    valid: lint.every((i) => i.severity !== "ERROR"),
+    schemaErrors: [],
+    lint,
+    stats: {
+      statements: pack.statements.length,
+      mappings: pack.mappings?.length ?? 0,
+      coveredStatements: covered.size,
+      statementOnlyStatements: pack.statements.length - covered.size,
+      gradeRange: [Math.min(...bands.flat()), Math.max(...bands.flat())]
+    }
+  };
+}
+
+// src/standards/standardsContextInjector.ts
+var DEFAULT_MAX_STATEMENTS = 20;
+function normalizeBand(band) {
+  return Array.isArray(band) ? band : [band, band];
+}
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 2)
+  );
+}
+function selectStatementsForLesson(input) {
+  const max = input.maxStatements ?? DEFAULT_MAX_STATEMENTS;
+  const lessonBand = normalizeBand(input.gradeBand);
+  const lessonTokens = tokenize(input.topicText);
+  const conceptSet = new Set((input.conceptCodes ?? []).map((c) => c.toUpperCase().trim()).filter(Boolean));
+  const candidates = [];
+  for (const pack of input.packs) {
+    for (const statement of pack.statements) {
+      const [sMin, sMax] = statement.gradeBand;
+      const overlaps = Math.max(sMin, lessonBand[0]) <= Math.min(sMax, lessonBand[1]);
+      if (!overlaps) continue;
+      const matchedBy = ["band"];
+      let score = 1;
+      const kwTokens = new Set(statement.keywords.map((k) => k.toLowerCase()));
+      let kwHits = 0;
+      for (const t of lessonTokens) if (kwTokens.has(t)) kwHits++;
+      if (kwHits > 0) {
+        matchedBy.push("keyword");
+        score += 2 + kwHits * 0.5;
+      }
+      if (conceptSet.size > 0) {
+        for (const k of statement.keywords) {
+          if (conceptSet.has(k.toUpperCase().replace(/\s+/g, "_"))) {
+            matchedBy.push("concept");
+            score += 3;
+            break;
+          }
+        }
+      }
+      let textHits = 0;
+      for (const lang of Object.keys(statement.texts)) {
+        const st = tokenize(statement.texts[lang]);
+        for (const t of lessonTokens) if (st.has(t)) textHits++;
+      }
+      if (textHits >= 2) {
+        matchedBy.push("text");
+        score += Math.min(2, textHits * 0.2);
+      }
+      if (score > 1) candidates.push({ packId: pack.manifest.id, statement, score, matchedBy });
+    }
+  }
+  return candidates.sort((a, b) => b.score - a.score).slice(0, max);
+}
+function buildStandardsContextBlock(selected, opts) {
+  if (selected.length === 0) return "";
+  const lang = opts?.language;
+  const rows = selected.map(({ packId, statement }) => {
+    const text = lang && statement.texts[lang] || Object.values(statement.texts)[0];
+    const band = statement.gradeBand[0] === statement.gradeBand[1] ? `L${statement.gradeBand[0]}` : `L${statement.gradeBand[0]}-L${statement.gradeBand[1]}`;
+    return `- [${packId}:${statement.id} | ${band}] "${text}"`;
+  }).join("\n");
+  return [
+    "# STANDARDS CONTEXT (SOURCE OF TRUTH \u2014 VERBATIM STATEMENTS)",
+    "",
+    "The statements below are COPIED VERBATIM from official/framework standard documents adopted for this course.",
+    "They are BINDING targets, not suggestions:",
+    "- Every Learning Objective you write MUST be anchored to one or more statement IDs above via standardRefs.",
+    "- You MUST use ONLY statement IDs from this list. NEVER invent, paraphrase IDs, or cite standards not present here.",
+    "- The statement TEXT is the required destination: activities and assessments must demonstrably lead a learner to it.",
+    "- The statement is the DESTINATION, not a script: you may extend beyond it, but you may not skip or contradict it.",
+    "",
+    "## Statement list",
+    rows
+  ].join("\n");
+}
+function buildStandardsContext(input) {
+  const selected = selectStatementsForLesson(input);
+  return { block: buildStandardsContextBlock(selected, { language: input.language }), selected };
+}
+
+// src/standards/standardsCoverageGate.ts
+function resolveStatementRef(ref, packs) {
+  const [head, ...rest] = ref.split(":");
+  const candidatePacks = rest.length > 0 ? packs.filter((p) => p.manifest.id === head) : packs;
+  const statementId = rest.length > 0 ? rest.join(":") : ref;
+  for (const p of candidatePacks) {
+    if (p.statements.some((s) => s.id === statementId)) return { pack: p, statementId };
+  }
+  return null;
+}
+function evaluateStandardsCoverage(input) {
+  const rows = [];
+  const aoToLo = /* @__PURE__ */ new Map();
+  for (const ao of input.assessmentObjectives ?? []) aoToLo.set(ao.aoCode, ao.alignedLO);
+  const loToRefs = /* @__PURE__ */ new Map();
+  for (const lo of input.objectives) {
+    loToRefs.set(lo.code, new Set(lo.standardRefs ?? []));
+  }
+  const taughtLOs = /* @__PURE__ */ new Set();
+  for (const act of input.activities ?? []) for (const lo of act.lo) taughtLOs.add(lo);
+  const assessedLOs = /* @__PURE__ */ new Set();
+  for (const q of input.quizQuestions) {
+    if (q.alignedLO) assessedLOs.add(q.alignedLO);
+    if (q.alignedAO) {
+      const lo = aoToLo.get(q.alignedAO);
+      if (lo) assessedLOs.add(lo);
+    }
+  }
+  for (const pack of input.packs) {
+    const mappingByStatement = /* @__PURE__ */ new Map();
+    for (const m of pack.mappings ?? []) {
+      const prev = mappingByStatement.get(m.statementId);
+      if (!prev || prev !== "covers" && m.kind === "covers" || prev === "extends" && m.kind !== "extends") {
+        mappingByStatement.set(m.statementId, m.kind);
+      }
+    }
+    for (const statement of pack.statements) {
+      const refFull = `${pack.manifest.id}:${statement.id}`;
+      const issues = [];
+      const los = input.objectives.filter((lo) => (lo.standardRefs ?? []).some((r) => r === statement.id || r === refFull)).map((lo) => lo.code);
+      const kind = mappingByStatement.get(statement.id);
+      const hasMapping = kind !== void 0;
+      const isComplianceRelevant = kind === "covers";
+      const hasActivity = los.some((lo) => taughtLOs.has(lo));
+      const hasAssessment = los.some((lo) => assessedLOs.has(lo));
+      let status;
+      if (!hasMapping) status = "UNMAPPED";
+      else if (!isComplianceRelevant) status = "PARTIAL";
+      else if (los.length > 0 && hasActivity && hasAssessment) status = "COVERED";
+      else status = "UNCOVERED";
+      if (status === "UNCOVERED") {
+        if (los.length === 0) issues.push("No learning objective anchors this statement (missing standardRefs).");
+        else {
+          if (!hasActivity) issues.push(`Anchored LO(s) ${los.join(", ")} have no activity in lesson flow.`);
+          if (!hasAssessment) issues.push(`Anchored LO(s) ${los.join(", ")} are not measured by any quiz question.`);
+        }
+      }
+      rows.push({
+        packId: pack.manifest.id,
+        statementId: statement.id,
+        statementText: Object.values(statement.texts)[0] ?? "",
+        status,
+        objectives: los,
+        hasActivity,
+        hasAssessment,
+        issues
+      });
+    }
+  }
+  for (const lo of input.objectives) {
+    for (const r of lo.standardRefs ?? []) {
+      if (!resolveStatementRef(r, input.packs)) {
+        rows.push({
+          packId: "(unresolved)",
+          statementId: r,
+          statementText: "",
+          status: "UNCOVERED",
+          objectives: [lo.code],
+          hasActivity: false,
+          hasAssessment: false,
+          issues: [`standardRef "${r}" does not exist in any adopted pack \u2014 likely a hallucinated or stale ID`]
+        });
+      }
+    }
+  }
+  const complianceRows = rows.filter((r) => r.status !== "UNMAPPED" && r.status !== "PARTIAL");
+  const covered = complianceRows.filter((r) => r.status === "COVERED").length;
+  const coveragePct = complianceRows.length === 0 ? 100 : Math.round(covered / complianceRows.length * 100);
+  const unresolvedCount = rows.filter((r) => r.packId === "(unresolved)").length;
+  const verdict = unresolvedCount > 0 || coveragePct < 60 ? "FAIL" : coveragePct < 100 ? "WARN" : "PASS";
+  const lines = [
+    "# Standards Coverage Report",
+    "",
+    `- Verdict: **${verdict}**`,
+    `- Compliance coverage: **${coveragePct}%** (${covered}/${complianceRows.length} "covers" statements fully taught + assessed)`,
+    `- Unresolved standardRefs: ${unresolvedCount}`,
+    "",
+    "| Pack | Statement | Status | LOs | Activity | Assessment |",
+    "|---|---|---|---|---|---|",
+    ...rows.map(
+      (r) => `|${r.packId}|${r.statementId}|${r.status}|${r.objectives.join(", ") || "\u2014"}|${r.hasActivity ? "\u2713" : "\u2717"}|${r.hasAssessment ? "\u2713" : "\u2717"}|`
+    )
+  ];
+  const issueLines = rows.filter((r) => r.issues.length > 0).flatMap((r) => r.issues.map((i) => `- [${r.packId}:${r.statementId}] ${i}`));
+  if (issueLines.length > 0) lines.push("", "## Issues", ...issueLines);
+  return {
+    verdict,
+    coveragePct,
+    rows,
+    summary: `Standards coverage ${coveragePct}% \u2014 verdict ${verdict}`,
+    rawMarkdownReport: lines.join("\n")
+  };
+}
+var StandardsRegistryAdapter = class {
+  client;
+  constructor(config = {}) {
+    if (config.client) {
+      this.client = config.client;
+      return;
+    }
+    const url = config.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || "";
+    const key = config.supabaseServiceRoleKey || process.env.SUPABASE_SERVICE_ROLE_KEY || config.supabaseAnonKey || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
+    if (!url || !key) {
+      throw new Error("StandardsRegistryAdapter: Supabase URL/key missing (pass client or env).");
+    }
+    this.client = supabaseJs.createClient(url, key);
+  }
+  // ─── Intake (write path — service role) ───────────────────────────────────
+  /** Persist a schema-validated pack as a new framework (status=draft). */
+  async importPack(pack, opts) {
+    const parsed = FrameworkPackSchema.safeParse(pack);
+    if (!parsed.success) {
+      throw new Error("importPack: pack failed schema validation: " + parsed.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; "));
+    }
+    const p = parsed.data;
+    const { data: fw, error: fwErr } = await this.client.from("standards_frameworks").insert({
+      pack_id: p.manifest.id,
+      content_version: p.manifest.contentVersion,
+      name: p.manifest.name,
+      spec_version: p.manifest.specVersion,
+      subject: p.manifest.subject,
+      languages: p.manifest.languages,
+      grade_model: p.manifest.gradeModel,
+      provenance: p.manifest.provenance,
+      trust: p.manifest.trust,
+      status: "draft",
+      organization_code: opts?.organizationCode ?? (p.manifest.trust === "verified" ? null : p.manifest.provenance.importedBy?.replace(/^org:/, "") || null),
+      original_file_path: opts?.originalFilePath ?? null,
+      created_by: opts?.createdBy ?? null
+    }).select("id").single();
+    if (fwErr) throw new Error("importPack: framework insert failed: " + fwErr.message);
+    const frameworkId = fw.id;
+    const statementRows = p.statements.map((s) => ({
+      framework_id: frameworkId,
+      statement_id: s.id,
+      parent_statement_id: s.parentId ?? null,
+      grade_min: s.gradeBand[0],
+      grade_max: s.gradeBand[1],
+      texts: s.texts,
+      classifications: s.classifications ?? [],
+      bloom_hint: s.bloomHint ?? null,
+      keywords: s.keywords ?? [],
+      source_ref: s.sourceRef ?? null,
+      provenance: s.provenance
+    }));
+    const { error: stErr, count: stCount } = await this.client.from("standards_statements").insert(statementRows, { count: "exact" });
+    if (stErr) throw new Error("importPack: statement insert failed: " + stErr.message);
+    let mappingCount = 0;
+    if (p.mappings && p.mappings.length > 0) {
+      const mappingRows = p.mappings.map((m) => ({
+        framework_id: frameworkId,
+        statement_id: m.statementId,
+        target_ref: m.targetRef,
+        kind: m.kind,
+        confidence: m.confidence,
+        provenance: m.provenance
+      }));
+      const { error: mpErr, count: mpCount } = await this.client.from("standards_mappings").insert(mappingRows, { count: "exact" });
+      if (mpErr) throw new Error("importPack: mapping insert failed: " + mpErr.message);
+      mappingCount = mpCount ?? mappingRows.length;
+    }
+    return { frameworkDbId: frameworkId, statementsInserted: stCount ?? statementRows.length, mappingsInserted: mappingCount };
+  }
+  /** Activate a draft framework (immutable version is now live). */
+  async activatePack(frameworkDbId) {
+    const { error } = await this.client.from("standards_frameworks").update({ status: "active" }).eq("id", frameworkDbId).eq("status", "draft");
+    if (error) throw new Error("activatePack failed: " + error.message);
+  }
+  async deprecatePack(frameworkDbId) {
+    const { error } = await this.client.from("standards_frameworks").update({ status: "deprecated" }).eq("id", frameworkDbId);
+    if (error) throw new Error("deprecatePack failed: " + error.message);
+  }
+  async adoptPack(frameworkDbId, organizationCode, adoptedBy) {
+    const { error } = await this.client.from("standards_org_adoptions").upsert(
+      { framework_id: frameworkDbId, organization_code: organizationCode, adopted_by: adoptedBy ?? null },
+      { onConflict: "organization_code,framework_id" }
+    );
+    if (error) throw new Error("adoptPack failed: " + error.message);
+  }
+  // ─── Runtime (read path — generation) ─────────────────────────────────────
+  /**
+   * Load all packs usable by an org: platform packs (verified, org IS NULL) +
+   * org packs + org adoptions. Hydrated into the same FrameworkPack shape the
+   * in-memory Phase-1 components consume (injector / coverage gate / judge).
+   */
+  async loadPacksForOrg(organizationCode) {
+    let query = this.client.from("standards_frameworks").select("*, standards_org_adoptions(organization_code)").eq("status", "active");
+    const { data: frameworks, error } = await query;
+    if (error) throw new Error("loadPacksForOrg: " + error.message);
+    const visible = (frameworks ?? []).filter((f) => {
+      const own = f.organization_code && organizationCode && f.organization_code === organizationCode;
+      const global = !f.organization_code;
+      const adopted = organizationCode && (f.standards_org_adoptions ?? []).some((a) => a.organization_code === organizationCode);
+      return global || own || adopted;
+    });
+    if (visible.length === 0) return [];
+    const ids = visible.map((f) => f.id);
+    const [{ data: statements, error: stErr }, { data: mappings, error: mpErr }, { data: overrides, error: ovErr }] = await Promise.all([
+      this.client.from("standards_statements").select("*").in("framework_id", ids),
+      this.client.from("standards_mappings").select("*").in("framework_id", ids),
+      this.client.from("standards_mapping_overrides").select("*").in("framework_id", ids)
+    ]);
+    if (stErr) throw new Error("loadPacksForOrg statements: " + stErr.message);
+    const overridesByFw = /* @__PURE__ */ new Map();
+    for (const o of overrides ?? []) {
+      const list = overridesByFw.get(o.framework_id) ?? [];
+      list.push(o);
+      overridesByFw.set(o.framework_id, list);
+    }
+    return visible.map((f) => {
+      const stmts = (statements ?? []).filter((s) => s.framework_id === f.id).map((s) => ({
+        id: s.statement_id,
+        parentId: s.parent_statement_id ?? void 0,
+        gradeBand: [s.grade_min, s.grade_max],
+        texts: s.texts,
+        classifications: s.classifications ?? [],
+        bloomHint: s.bloom_hint ?? void 0,
+        keywords: s.keywords ?? [],
+        sourceRef: s.source_ref ?? void 0,
+        provenance: s.provenance ?? { method: "imported" }
+      }));
+      const ov = overridesByFw.get(f.id) ?? [];
+      const retired = new Set(ov.filter((o) => o.kind === "retired").map((o) => o.statement_id + "|" + o.target_ref));
+      const embedded = (mappings ?? []).filter((m) => m.framework_id === f.id).map((m) => ({
+        statementId: m.statement_id,
+        targetRef: m.target_ref,
+        kind: m.kind,
+        confidence: Number(m.confidence),
+        provenance: m.provenance ?? { method: "imported" }
+      }));
+      const overlay = ov.filter((o) => o.kind !== "retired").map((o) => ({
+        statementId: o.statement_id,
+        targetRef: o.target_ref,
+        kind: o.kind,
+        confidence: Number(o.confidence),
+        provenance: { method: "human", reviewedBy: o.created_by ?? "overlay", note: o.note ?? void 0 }
+      }));
+      const bridge = /* @__PURE__ */ new Map();
+      for (const m of embedded) bridge.set(m.statementId + "|" + m.targetRef, m);
+      for (const m of overlay) bridge.set(m.statementId + "|" + m.targetRef, m);
+      const finalMappings = [...bridge.values()].filter((m) => !retired.has(m.statementId + "|" + m.targetRef));
+      const hydrated = FrameworkPackSchema.safeParse({
+        manifest: {
+          id: f.pack_id,
+          name: f.name,
+          specVersion: f.spec_version || "1.0",
+          contentVersion: f.content_version,
+          subject: f.subject,
+          languages: f.languages,
+          gradeModel: f.grade_model,
+          provenance: f.provenance,
+          trust: f.trust
+        },
+        statements: stmts,
+        mappings: finalMappings
+      });
+      if (!hydrated.success) {
+        throw new Error('loadPacksForOrg: hydrated pack "' + f.pack_id + '" failed schema: ' + hydrated.error.issues[0]?.message);
+      }
+      return { ...hydrated.data, dbId: f.id, status: f.status, organizationCode: f.organization_code ?? null };
+    });
+  }
+};
+
+// src/standards/standardStackGenerator.ts
+function bandLabel(band) {
+  return band[0] === band[1] ? `L${band[0]}` : `L${band[0]}\u2013L${band[1]}`;
+}
+function buildStandardStackMarkdown(opts) {
+  const { projectId, packs, courseGradeBand, language } = opts;
+  const lines = [];
+  lines.push("---");
+  lines.push(`id: "${projectId.toUpperCase()}-STANDARD-STACK"`);
+  lines.push(`title: "Standard Stack: ${projectId}"`);
+  lines.push('type: "STANDARD_STACK"');
+  lines.push('phase: "P1"');
+  lines.push('version: "v2.0-deterministic"');
+  lines.push(`generatedAt: "${(/* @__PURE__ */ new Date()).toISOString()}"`);
+  lines.push('source: "Standards Registry (deterministic render \u2014 not LLM-generated)"');
+  lines.push("---");
+  lines.push("");
+  lines.push("# STANDARD STACK \u2014 H\u1EC7 ti\xEAu chu\u1EA9n tham chi\u1EBFu");
+  lines.push("");
+  if (packs.length === 0) {
+    lines.push("> \u26A0\uFE0F No Framework Pack adopted for this course. Generation will run WITHOUT standards grounding");
+    lines.push("> (no statement anchoring, no Standards Alignment judge dimension, no coverage gate).");
+    lines.push("> Import a pack via the Standards Registry before generating for standards-bound courses.");
+    return lines.join("\n");
+  }
+  for (const pack of packs) {
+    const m = pack.manifest;
+    lines.push(`## ${m.name}`);
+    lines.push("");
+    lines.push(`- **Pack ID:** \`${m.id}\` (content ${m.contentVersion}, contract v${m.specVersion})`);
+    lines.push(`- **Trust:** ${m.trust} \u2014 ${m.trust === "verified" ? "platform-curated" : "org-imported"}`);
+    lines.push(`- **Ngu\u1ED3n:** ${m.provenance.sourceRef}${m.provenance.sourceUrl ? " (" + m.provenance.sourceUrl + ")" : ""}`);
+    lines.push(`- **License:** ${m.provenance.license}`);
+    lines.push(`- **Grade range (manifest):** ${bandLabel(m.gradeModel.range)}`);
+    lines.push("");
+    lines.push("### Statements (verbatim \u2014 binding targets)");
+    lines.push("");
+    lines.push("| ID | Band | Text (verbatim) | Keywords |");
+    lines.push("|---|---|---|---|");
+    const statements = courseGradeBand ? pack.statements.filter((s) => Math.max(s.gradeBand[0], courseGradeBand[0]) <= Math.min(s.gradeBand[1], courseGradeBand[1])) : pack.statements;
+    for (const s of statements) {
+      const text = language && s.texts[language] || Object.values(s.texts)[0];
+      const mapped = (pack.mappings ?? []).filter((mp) => mp.statementId === s.id);
+      const mapNote = mapped.length > 0 ? ` \u2192 ${mapped.map((mp) => mp.targetRef + " (" + mp.kind + ")").join(", ")}` : "";
+      lines.push(`| \`${s.id}\` | ${bandLabel(s.gradeBand)} | ${text.replace(/\|/g, "\\|")} | ${(s.keywords || []).join(", ")}${mapNote ? " |" + mapNote : " |"}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Document rendered deterministically from the Standards Registry. Statement texts are COPIED VERBATIM from the cited sources and are binding for generation, judging, and coverage reporting.*");
+  return lines.join("\n");
+}
+
+// src/standards/data/csta-k12-2017.json
+var csta_k12_2017_default = {
+  manifest: {
+    id: "csta-k12-2017",
+    name: "CSTA K-12 Computer Science Standards (2017)",
+    specVersion: "1.0",
+    contentVersion: "2017.1",
+    subject: "computing",
+    languages: [
+      "en"
+    ],
+    gradeModel: {
+      type: "grades",
+      range: [
+        3,
+        12
+      ]
+    },
+    provenance: {
+      sourceRef: "CSTA K-12 Computer Science Standards, Revised 2017 - csteachers.org",
+      sourceUrl: "https://www.csteachers.org/page/standards",
+      license: "CC BY-NC-SA 4.0 (cited verbatim for alignment use)",
+      importedBy: "platform",
+      importedAt: "2026-08-29T00:00:00.000Z"
+    },
+    trust: "verified"
+  },
+  statements: [
+    {
+      id: "1B-AP-08",
+      gradeBand: [
+        6,
+        8
+      ],
+      texts: {
+        en: "Demonstrate that programs can be combined with other programs to create new solutions."
+      },
+      classifications: [
+        {
+          axis: "strand",
+          value: "Algorithms & Programming"
+        }
+      ],
+      bloomHint: {
+        process: "Apply"
+      },
+      keywords: [
+        "combine",
+        "programs",
+        "composition",
+        "reuse",
+        "modules"
+      ],
+      sourceRef: "CSTA K-12 2017, Level 1B (Grades 6-8), Algorithms & Programming",
+      provenance: {
+        method: "source_official"
+      }
+    },
+    {
+      id: "1B-AP-10",
+      gradeBand: [
+        6,
+        8
+      ],
+      texts: {
+        en: "Create programs that include sequences, events, loops, and conditionals."
+      },
+      classifications: [
+        {
+          axis: "strand",
+          value: "Algorithms & Programming"
+        }
+      ],
+      bloomHint: {
+        process: "Create",
+        knowledge: "PROCEDURAL"
+      },
+      keywords: [
+        "sequence",
+        "events",
+        "loops",
+        "conditionals",
+        "control structures",
+        "for",
+        "while"
+      ],
+      sourceRef: "CSTA K-12 2017, Level 1B (Grades 6-8), Algorithms & Programming",
+      provenance: {
+        method: "source_official"
+      }
+    },
+    {
+      id: "1B-AP-11",
+      gradeBand: [
+        6,
+        8
+      ],
+      texts: {
+        en: "Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process."
+      },
+      classifications: [
+        {
+          axis: "strand",
+          value: "Algorithms & Programming"
+        }
+      ],
+      bloomHint: {
+        process: "Analyze"
+      },
+      keywords: [
+        "decomposition",
+        "subproblems",
+        "problem breakdown",
+        "algorithm",
+        "divide"
+      ],
+      sourceRef: "CSTA K-12 2017, Level 1B (Grades 6-8), Algorithms & Programming",
+      provenance: {
+        method: "source_official"
+      }
+    },
+    {
+      id: "1B-AP-12",
+      gradeBand: [
+        6,
+        8
+      ],
+      texts: {
+        en: "Modify, remix, or include portions of other programs in one's own work to develop something new or add more advanced features."
+      },
+      classifications: [
+        {
+          axis: "strand",
+          value: "Algorithms & Programming"
+        }
+      ],
+      bloomHint: {
+        process: "Create"
+      },
+      keywords: [
+        "remix",
+        "modify",
+        "iterate",
+        "extend programs"
+      ],
+      sourceRef: "CSTA K-12 2017, Level 1B (Grades 6-8), Algorithms & Programming",
+      provenance: {
+        method: "source_official"
+      }
+    },
+    {
+      id: "1B-AP-15",
+      gradeBand: [
+        6,
+        8
+      ],
+      texts: {
+        en: "Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended."
+      },
+      classifications: [
+        {
+          axis: "strand",
+          value: "Algorithms & Programming"
+        }
+      ],
+      bloomHint: {
+        process: "Evaluate"
+      },
+      keywords: [
+        "test",
+        "debug",
+        "errors",
+        "troubleshooting",
+        "fix"
+      ],
+      sourceRef: "CSTA K-12 2017, Level 1B (Grades 6-8), Algorithms & Programming",
+      provenance: {
+        method: "source_official"
+      }
+    },
+    {
+      id: "1B-IC-21",
+      gradeBand: [
+        6,
+        8
+      ],
+      texts: {
+        en: "Use public domain or creative commons media, and refrain from copying or using material created by others without permission."
+      },
+      classifications: [
+        {
+          axis: "strand",
+          value: "Impacts of Computing"
+        }
+      ],
+      bloomHint: {
+        process: "Apply"
+      },
+      keywords: [
+        "copyright",
+        "creative commons",
+        "public domain",
+        "digital citizenship",
+        "license"
+      ],
+      sourceRef: "CSTA K-12 2017, Level 1B (Grades 6-8), Impacts of Computing",
+      provenance: {
+        method: "source_official"
+      }
+    }
+  ],
+  mappings: [
+    {
+      statementId: "1B-AP-10",
+      targetRef: "ontora:FOR_LOOP",
+      kind: "covers",
+      confidence: 0.85,
+      provenance: {
+        method: "human",
+        reviewedBy: "thanh01pmt"
+      }
+    },
+    {
+      statementId: "1B-AP-10",
+      targetRef: "ontora:WHILE_LOOP",
+      kind: "covers",
+      confidence: 0.85,
+      provenance: {
+        method: "human",
+        reviewedBy: "thanh01pmt"
+      }
+    },
+    {
+      statementId: "1B-AP-11",
+      targetRef: "ontora:PROBLEM_DECOMPOSITION",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: {
+        method: "human",
+        reviewedBy: "thanh01pmt"
+      }
+    },
+    {
+      statementId: "1B-AP-08",
+      targetRef: "ontora:EVENT_BASED_PROGRAMMING",
+      kind: "partial",
+      confidence: 0.7,
+      provenance: {
+        method: "ai_draft",
+        reviewedBy: "thanh01pmt"
+      }
+    },
+    {
+      statementId: "1B-AP-15",
+      targetRef: "ontora:TROUBLESHOOTING_STEPS",
+      kind: "covers",
+      confidence: 0.9,
+      provenance: {
+        method: "ai_draft",
+        reviewedBy: "thanh01pmt"
+      }
+    }
+  ]
+};
+
+// src/standards/bundledPacks.ts
+var BUNDLED_PACK_RECORDS = {
+  "csta-k12-2017": csta_k12_2017_default
+};
+var BUNDLED_STANDARDS_PACK_IDS = Object.keys(BUNDLED_PACK_RECORDS).sort();
+var parsedPackCache = /* @__PURE__ */ new Map();
+function resolveStandardsPacks(packIds) {
+  if (!packIds || packIds.length === 0) return [];
+  const packs = [];
+  for (const id of packIds) {
+    if (parsedPackCache.has(id)) {
+      packs.push(parsedPackCache.get(id));
+      continue;
+    }
+    const raw = BUNDLED_PACK_RECORDS[id];
+    if (!raw) {
+      console.warn(`[standards] pack '${id}' kh\xF4ng t\u1ED3n t\u1EA1i trong kit \u2014 b\u1ECF qua.`);
+      continue;
+    }
+    const parsed = FrameworkPackSchema.safeParse(raw);
+    if (!parsed.success) {
+      console.warn(`[standards] pack '${id}' fail schema \u2014 b\u1ECF qua:`, parsed.error.issues[0]?.message);
+      continue;
+    }
+    parsedPackCache.set(id, parsed.data);
+    packs.push(parsed.data);
+  }
+  return packs;
+}
+
+exports.BUNDLED_STANDARDS_PACK_IDS = BUNDLED_STANDARDS_PACK_IDS;
+exports.BloomHintSchema = BloomHintSchema;
+exports.ClassificationSchema = ClassificationSchema;
+exports.FrameworkMappingSchema = FrameworkMappingSchema;
+exports.FrameworkPackManifestSchema = FrameworkPackManifestSchema;
+exports.FrameworkPackSchema = FrameworkPackSchema;
+exports.FrameworkStatementSchema = FrameworkStatementSchema;
+exports.GradeBandSchema = GradeBandSchema;
+exports.MappingKindSchema = MappingKindSchema;
+exports.RecordProvenanceSchema = RecordProvenanceSchema;
+exports.StandardsRegistryAdapter = StandardsRegistryAdapter;
+exports.buildStandardStackMarkdown = buildStandardStackMarkdown;
+exports.buildStandardsContext = buildStandardsContext;
+exports.buildStandardsContextBlock = buildStandardsContextBlock;
+exports.evaluateStandardsCoverage = evaluateStandardsCoverage;
+exports.lintFrameworkPack = lintFrameworkPack;
+exports.resolveStandardsPacks = resolveStandardsPacks;
+exports.selectStatementsForLesson = selectStatementsForLesson;
+exports.validateFrameworkPack = validateFrameworkPack;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map