@thanh01.pmt/curriculum-kit 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,747 @@
+import { PlanConstraints, TranslationPolicy, CurriculumPlan, PlanningGraph, PlanningNode, DependencyEdge, LessonPlan, DiagnosticQuizInput, ActivityLab, SlideDeck, CodeLab, DiagnosticQuiz } from './schemas/index.js';
+export { ActiveLearningWorkflow, ActiveLearningWorkflowSchema, ActivityLabSchema, ActivitySeqRow, ActivitySeqRowSchema, ActivityStepSchema, ArtifactContractRowSchema, AssessmentMapRowSchema, AssessmentObjective, AssessmentObjectiveSchema, BellRinger, BellRingerDay, BellRingerDaySchema, BellRingerInput, BellRingerSchema, BloomLevel, BloomLevelSchema, BronzeTier, BronzeTierSchema, CERConclusion, CERConclusionSchema, CardTierEnum, ChoiceBoard, ChoiceBoardInput, ChoiceBoardRubricRowSchema, ChoiceBoardSchema, ChoiceRuleSchema, ChoiceSquare, ChoiceSquareSchema, CodeLabSchema, CodeSnippet, CodeSnippetSchema, CompetencyRubricRow, CompetencyRubricRowSchema, ComputationalThinking, ComputationalThinkingSchema, CoreConcept, CoreConceptSchema, CourseObjective, CourseObjectiveSchema, CoverageReport, CoverageReportSchema, CurriculumArtifact, CurriculumArtifactSchema, CurriculumPlanSchema, CurriculumQualityReport, CurriculumQualityReportSchema, DependencyEdgeSchema, DepthAssignment, DepthAssignmentSchema, DepthLevel, DepthLevelSchema, DiagnosticQuestion, DiagnosticQuestionInput, DiagnosticQuestionSchema, DiagnosticQuizSchema, EDPPhaseEnum, EntryLevelSchema, ExitTicket, ExitTicketBugHunt, ExitTicketBugHuntSchema, ExitTicketMetacognitionSchema, ExitTicketQuickItemSchema, ExitTicketRecallPromptSchema, ExitTicketSchema, ExperimentalDesignSchema, Extension, ExtensionChallengeSchema, ExtensionSchema, FiveEFlowPhaseSchema, FiveEPhaseEnum, Glossary, GlossaryInput, GlossaryQuickRefRowSchema, GlossarySchema, GlossaryTerm, GlossaryTermSchema, GoldTier, GoldTierSchema, GraphicOrganizer, GraphicOrganizerInput, GraphicOrganizerItem, GraphicOrganizerItemSchema, GraphicOrganizerSchema, Handout, HandoutSchema, HandoutSection, HandoutSectionSchema, InstructionSection, InstructionSectionSchema, InstructionStep, InstructionStepSchema, JudgeCriterionSchema, LabTierTask, LabTierTaskSchema, LearningObjectiveInput, LearningObjectiveInputSchema, LearningObjectiveRow, LearningObjectiveRowSchema, LessonFlowPhase, LessonFlowPhaseSchema, LessonPlan5E, LessonPlan5ESchema, LessonPlanEDP, LessonPlanEDPSchema, LessonPlanSchema, LessonSectionSchema, MarpSlide, MarpSlideSchema, MentorCheatsheetSchema, MilestoneInput, MilestoneInputSchema, Misconception, MisconceptionSchema, NodeKindSchema, OrganizerTypeEnum, PhaseInput, PhaseInputSchema, PlanConstraintsSchema, PlannerInput, PlannerInputSchema, PlanningGraphSchema, PlanningNodeSchema, PlanningPhase, PrerequisiteDecision, PrerequisiteDecisionEntry, PrerequisiteDecisionEntrySchema, PrerequisiteDecisionSchema, ProductGoalSchema, ProgressiveHints, ProgressiveHintsSchema, ProjectGraph, ProjectGraphSchema, ProjectInstruction, ProjectInstructionSchema, ProjectProfile, ProjectProfileSchema, ProjectRoadmap, QualityAuditVerdictSchema, QuizOption, QuizOptionSchema, ResourceMapRowSchema, ReviewGame, ReviewGameExportRowSchema, ReviewGameInput, ReviewGameQuestion, ReviewGameQuestionSchema, ReviewGameSchema, RoadmapInput, RoadmapInputSchema, RotationStation, RotationStationSchema, Rubric, RubricCriteria, RubricCriteriaSchema, RubricSchema, ScaffoldDecision, ScaffoldDecisionEntry, ScaffoldDecisionEntrySchema, ScaffoldDecisionSchema, ScienceLab, ScienceLabInput, ScienceLabSchema, ScoringRubricRowSchema, SelfLab, SelfLabSchema, SelfPacedBundle, SelfPacedBundleSchema, SelfPacedChallenge, SelfPacedChallengeSchema, SessionPlan, SessionPlanSchema, SilverTier, SilverTierSchema, SlideDeckSchema, StandardizedTermRowSchema, StationRecordRowSchema, StationRotation, StationRotationInput, StationRotationSchema, StationTypeEnum, TaskCard, TaskCardSchema, TaskCards, TaskCardsInput, TaskCardsSchema, TeacherGuide, TeacherGuideSchema, TeachingScriptPhase, TeachingScriptPhaseSchema, TierLevelEnum, TierObjectiveSchema, TieredPractice, TieredPracticeSchema, TranslationPolicySchema, TroubleshootingEntry, TroubleshootingEntrySchema, TroubleshootingRow, TroubleshootingRowSchema, UnitPlan, UnitPlanSchema, UserJourneySchema, Worksheet, WorksheetItem, WorksheetItemSchema, WorksheetItemTypeEnum, WorksheetPart, WorksheetPartSchema, WorksheetSchema, validateCurriculumPlan } from './schemas/index.js';
+import { M as ModelResolutionOptions } from './provider-factory-DH3udYlN.js';
+export { A as AIProviderName, N as NVIDIA_MODELS, g as getAIModel } from './provider-factory-DH3udYlN.js';
+export { ActivityPromptInput, AggregatedToolCall, AsyncLLMJudgeInput, AuditCurriculumQualityInput, CodeLabPromptInput, DEFAULT_ENABLED_PROVIDERS, DiagnosticQuizPromptInput, ExtensionPromptInput, GenerateActivityInput, GenerateCodeLabInput, GenerateDiagnosticQuizInput, GenerateExtensionInput, GenerateHandoutInput, GenerateLessonMasterInput, GenerateProjectInstructionInput, GenerateSelfLabInput, GenerateSlidesInput, GenerateTeacherGuideInput, GenerateWorksheetInput, HandoutPromptInput, JudgeEvaluationResult, JudgePromptInput, LLMJudgeEngine, LessonPromptInput, ModelPolicyResolution, ModelPolicyResolver, ModelProviderKey, MultiProviderPolicyResolution, ProjectInstructionPromptInput, SelfLabPromptInput, SlidesPromptInput, StreamDiagnosticQuizInput, StreamLessonMasterInput, StreamSelfLabInput, TeacherGuidePromptInput, ToolDefinition, ToolExecutionResult, ToolExecutor, ToolLoopConfig, WorksheetPromptInput, activityTools, analystTools, assessorTools, auditCurriculumQualityFlow, buildActivityPrompt, buildCodeLabPrompt, buildDiagnosticQuizPrompt, buildExtensionPrompt, buildHandoutPrompt, buildJudgePrompt, buildLessonMasterPrompt, buildProjectInstructionPrompt, buildSelfLabPrompt, buildSlidesPrompt, buildTeacherGuidePrompt, buildWorksheetPrompt, contentTools, designerTools, generateActivityFlow, generateCodeLabFlow, generateDiagnosticQuizFlow, generateExtensionFlow, generateHandoutFlow, generateLessonMasterFlow, generateProjectInstructionFlow, generateSelfLabFlow, generateSlidesFlow, generateTeacherGuideFlow, generateWorksheetFlow, illustratorTools, packagerTools, researcherTools, reviewerTools, streamCurriculumAIInferenceWithTools, streamDiagnosticQuizFlow, streamLessonMasterFlow, streamSelfLabFlow, techSmeTools } from './ai/index.js';
+export { C as ChatMessage, c as ChunkType, F as FallbackTarget, S as StreamRunnerOptions, e as extractThoughtAndContent, g as getDesignatedFallbackChain, b as getDesignatedFallbackConfig, a as isModelAllowed, i as isProviderEnabled, r as runCurriculumAIInference, s as streamCurriculumAIInference } from './streamRunner-C7j5LKon.js';
+export { ArtifactLintReport, ConvertedSotBundle, GenerateProjectInstructionOptions, GenerateRoadmapCurriculumOptions, GenerateSelfPacedBundleInput, LintIssue, ProjectInstructionResult, RoadmapCurriculumOutput, SelfPacedBundleOutput, convertRoadmapToFoundationSot, generateProjectInstruction, generateRoadmapCurriculum, generateSelfPacedBundle, importRoadmapToProject, lintAndSanitizeArtifact, serializeActivityToMarkdown, serializeCodeLabToMarkdown, serializeDiagnosticQuizToMarkdown, serializeHandoutToMarkdown, serializeLessonToMarkdown, serializeProjectInstructionToMarkdown, serializeSelfLabToMarkdown, validateMarkdownTables, validateMermaidSyntax } from './pipeline/index.js';
+export { A as AutoRepairOptions, a as AutoRepairResult, B as BundleTier, G as GenerateMilestoneBundleOptions, M as MilestoneCurriculumBundle, g as generateMilestoneCurriculumBundle, w as withAutoRepair } from './milestoneBundleGenerator-CbXhs1CP.js';
+import { I as ICurriculumStorage, P as ProjectStatusReport, S as SmartResumeContext, Q as QualityAuditReport } from './types-BUJGYiep.js';
+export { b as ArtifactLifecycleInfo, A as ArtifactLifecycleState, L as LessonArtifactSummary, c as PipelineState, R as ReviewRecord, a as SotDocument, T as TaskLifecycleState } from './types-BUJGYiep.js';
+export { FileSystemCurriculumAdapter, FileSystemStorageOptions, STANDARD_SOT_FILES, StorageFactoryOptions, SupabaseCurriculumAdapter, SupabaseStorageConfig, computeContentHash, createCurriculumStorage } from './storage/index.js';
+import { F as FrameworkPack } from './standardsCoverageGate-BWAkXY76.js';
+export { B as BloomHintSchema, C as ClassificationSchema, k as CoverageGateInput, m as CoverageGateReport, g as FrameworkMapping, c as FrameworkMappingSchema, e as FrameworkPackManifest, a as FrameworkPackManifestSchema, d as FrameworkPackSchema, f as FrameworkStatement, b as FrameworkStatementSchema, G as GradeBandSchema, h as MappingKind, M as MappingKindSchema, P as PackLintIssue, j as PackValidationResult, i as RecordProvenance, R as RecordProvenanceSchema, S as StatementCoverageRow, n as evaluateStandardsCoverage, l as lintFrameworkPack, v as validateFrameworkPack } from './standardsCoverageGate-BWAkXY76.js';
+import { ResolvedGateSettings } from './workflow/index.js';
+export { ApprovalPayload, CurriculumArtifactType, CurriculumGateMode, DEFAULT_GATE_SETTINGS, ExecuteWithRateLimitOptions, GateSettings, GenerateMasterLessonStepInput, GenerateRoadmapWorkflowInput, JudgeMasterLessonStepInput, JudgeSatelliteStepInput, MilestoneWorkflowInput, MilestoneWorkflowResult, RepairMasterLessonStepInput, RoadmapWorkflowSummary, SaveMilestoneArtifactsInput, SavedMilestoneResult, approvalPayloadSchema, gateModeFor, generateActivityStep, generateCodeLabStep, generateDiagnosticQuizStep, generateExtensionStep, generateHandoutStep, generateMasterLessonStep, generateMilestoneWorkflow, generateRoadmapWorkflow, generateSelfLabStep, generateSlidesStep, generateTeacherGuideStep, generateWorksheetStep, judgeMasterLessonStep, judgeSatelliteStep, lessonApprovalHook, parseGateSettings, publishToGitStep, publishToSupabaseStep, repairMasterLessonStep, resolveGateSettings, saveMilestoneToWorkspaceStep, withRateLimitBackoff } from './workflow/index.js';
+export { DeliveryPackResult, JobManifest, LocalWorkspaceManager, ParsedQuizQuestion, buildDeliveryPackages, exportAllProjectQuizzes, formatQuizzesToCsv, parseQuizMarkdown } from './publishers/index.js';
+export { G as GitPublishOptions, a as GitPublishResult, S as SupabasePublishOptions, b as SupabasePublishResult, p as publishToGitHub, c as publishToSupabase, u as uploadAssetToBucket } from './supabasePublisher-C627qXFT.js';
+export { BUNDLED_STANDARDS_PACK_IDS, HydratedPack, ImportPackResult, SelectedStatement, StandardStackOptions, StandardsRegistryAdapter, StandardsRegistryConfig, StandardsSelectionInput, buildStandardStackMarkdown, buildStandardsContext, buildStandardsContextBlock, resolveStandardsPacks, selectStatementsForLesson } from './standards/index.js';
+export { CurateOptions, CurationDecision, FulfillOptions, FulfillResult, GenCandidate, GenRanking, GenerateImageOptions, GeneratedImage, MediaError, MediaLedger, MediaLedgerEntry, MediaLedgerMode, MediaLedgerStatus, MediaPolicy, MediaPolicyMode, MediaProvider, SearchImageOptions, SearchVideoOptions, StockImage, StockVideo, buildImagePrompt, curateMediaLedger, fulfillMediaLedger, generateEducationalImage, injectMediaIntoMarkdown, rankGenCandidates, renderMediaPlaceholder, searchEducationalImages, searchEducationalVideos } from './media/index.js';
+import 'zod';
+import 'ai';
+import '@supabase/supabase-js';
+
+/**
+ * Service to generate high-level status, readiness reports, and resume guidance.
+ */
+declare function getProjectStatusReport(storage: ICurriculumStorage, projectId: string): Promise<ProjectStatusReport>;
+declare function getSmartResumeContext(storage: ICurriculumStorage, projectId: string): Promise<SmartResumeContext>;
+/**
+ * Dynamically resolves the required artifact scope from SOT (PROJECT_BRIEF.md or CURRICULUM_FRAMEWORK.md)
+ */
+declare function getProjectArtifactScope(storage: ICurriculumStorage, projectId: string): Promise<string[]>;
+declare function auditQualityReport(storage: ICurriculumStorage, projectId: string): Promise<QualityAuditReport>;
+
+interface BuildContextOptions {
+    activeArtifactRelPath?: string;
+    maxContentChars?: number;
+}
+/**
+ * Builds the complete Ground Truth curriculum context for LLM prompt ingestion.
+ */
+declare function buildCurriculumContext(storage: ICurriculumStorage, projectId: string, options?: BuildContextOptions): Promise<string>;
+
+interface ProjectBriefingData {
+    projectName?: string;
+    topic?: string;
+    context?: string;
+    language?: string;
+    targetAge?: string;
+    targetAgeTier?: string;
+    courseDuration?: string;
+    courseDurationTier?: string;
+    hardwarePlatform?: string | string[];
+    hardwareReadiness?: string;
+    pedagogy?: string;
+    depth?: string;
+    capstoneTheme?: string;
+    exitVision?: string;
+    primaryGoal?: string;
+    valueAndCertification?: string;
+    budgetAndHardwareBOM?: string;
+    cognitiveScaffolding?: string;
+    differentiationStrategy?: string;
+    assessmentStrategy?: string;
+    academicBenchmark?: string;
+    /** Adopted Framework Packs (Standards Registry) — STANDARD_STACK.md is rendered deterministically from these. */
+    standardsPacks?: FrameworkPack[];
+    brandingAndTone?: string;
+    recommendedToolchain?: string;
+    artifactScope?: string[];
+    specialRequirements?: string;
+    [key: string]: any;
+}
+/**
+ * Helper to load Markdown Template from docs/refs/templates
+ */
+declare function loadSotTemplate(templateFileName: string): string;
+/**
+ * Service to generate Phase 1 Foundation SOT artifacts (@analyst & @researcher) from Brief input.
+ */
+declare function generatePhase1SotArtifacts(storage: ICurriculumStorage, projectId: string, briefing: ProjectBriefingData, onProgress?: (agent: string, step: string) => void): Promise<{
+    learnerProfile: string;
+    projectBrief: string;
+    referencePack: string;
+    standardStack?: string;
+}>;
+/**
+ * Service to generate Phase 2 Architecture SOT artifacts (@designer) from approved Foundation.
+ */
+declare function generatePhase2SotArtifacts(storage: ICurriculumStorage, projectId: string, briefing: ProjectBriefingData, onProgress?: (agent: string, step: string) => void): Promise<{
+    framework: string;
+    styleGuide: string;
+    artDirection: string;
+    projectStatus: string;
+}>;
+
+/**
+ * 🛠️ Framework Linter — hợp đồng "1 buổi = 1 dòng đầy đủ" cho CURRICULUM_FRAMEWORK.md
+ *
+ * Framework là SOT của toàn bộ pipeline production: nếu framework thiếu objective/deliverable/prerequisite
+ * cho từng buổi, MỌI LESSON phía sau sinh sai. Linter này chạy NGAY SAU khi sinh framework
+ * (0 token, deterministic) và trả findings để caller retry có mục tiêu hoặc cảnh báo rõ ràng.
+ */
+interface FrameworkLintFinding {
+    code: string;
+    severity: 'CRITICAL' | 'MAJOR' | 'MINOR';
+    message: string;
+}
+interface FrameworkLintReport {
+    passed: boolean;
+    score: number;
+    totalLessons: number;
+    findings: FrameworkLintFinding[];
+    summary: string;
+}
+/**
+ * Trích các dòng dữ liệu từ bảng Scope & Sequence (bỏ header + separator).
+ * Nhận diện bảng theo header chứa cả "Lesson Code" và "Learning Objective".
+ */
+declare function extractScopeSequenceRows(framework: string): {
+    headerFound: boolean;
+    rows: string[][];
+};
+declare function lintCurriculumFramework(framework: string, expectedSessions?: number): FrameworkLintReport;
+
+/**
+ * Resolves and loads official canonical templates from docs/refs/templates or _templates/
+ */
+declare function loadCurriculumTemplate(templateName: string): string;
+type PedagogicalModel = '5e' | 'edp' | 'pbl' | 'general';
+interface ProduceLessonOptions {
+    artifactScope?: string[];
+    force?: boolean;
+    pedagogy?: PedagogicalModel;
+    /** Chiến lược batch (chỉ produceBatchLessons dùng). */
+    batchStrategy?: 'depth_first_lesson' | 'breadth_first_artifact';
+    /**
+     * Gate Settings — NGUỒN DUY NHẤT quyết định "ai kiểm artifact nào".
+     * Chấp nhận config thô (vd: gateModes từ project.config.json của Composer):
+     * { LESSON: 'llm_judge', ACT: 'none', gate1: 'hitl', ... } — kit tự chuẩn hoá.
+     * Riêng approvedArtifacts là INPUT của HITL (bản đã được người duyệt), không phải config.
+     */
+    gateSettings?: unknown;
+    /**
+     * Standards Registry packs (đã validate + activate) để GROUNDING prompt và Judge.
+     * Không truyền → pipeline chạy như cũ, không inject block chuẩn nào.
+     */
+    standardsPacks?: FrameworkPack[];
+    /** Id pack đóng gói sẵn trong kit (vd: 'csta-k12-2017') — cách Composer truyền chuẩn gọn nhất. */
+    standardsPackIds?: string[];
+    /** Grade band của lesson (để chọn statement theo lớp). Fallback [6,12]. */
+    gradeBand?: [number, number] | number;
+    /**
+     * Media Ledger policy (nếu có): agent chèn placeholder [IMAGE: slug], Curator duyệt, Fulfiller thực thi.
+     * maxGenImagesPerArtifact = quota ảnh AI/gen — search kho ảnh (Pexels) KHÔNG tốn quota này.
+     */
+    mediaPolicy?: {
+        maxGenImagesPerArtifact: number;
+        autoFulfill?: boolean;
+        preferredProvider?: 'openai' | 'gemini';
+        mode?: 'search_only' | 'gen_only' | 'auto';
+    };
+    approvedArtifacts?: string[];
+    onProgress?: (agent: string, message: string, meta?: any) => void;
+}
+interface ProduceLessonResult {
+    lessonId: string;
+    pedagogy: PedagogicalModel;
+    producedArtifacts: string[];
+    pausedForReview: boolean;
+    gateStatus?: string;
+}
+/**
+ * Detects pedagogical model from SOT (Framework, Style Guide, or Brief)
+ */
+declare function detectProjectPedagogy(frameworkText: string, styleGuideText: string, explicitPedagogy?: PedagogicalModel): PedagogicalModel;
+/**
+ * Extracts lesson information (Title, Concept, Bloom, Unit, Module) from CURRICULUM_FRAMEWORK.md.
+ */
+declare function getLessonMetadata(storage: ICurriculumStorage, projectId: string, lessonId: string): Promise<{
+    unitCode: string;
+    moduleCode: string;
+    lessonCode: string;
+    lessonTitle: string;
+    concept: string;
+    prerequisites: string;
+    bloomLevel: string;
+}>;
+/**
+ * Produces artifacts for a single lesson with support for dynamic pedagogy, HITL gating, and artifact scope.
+ */
+declare function produceSingleLesson(storage: ICurriculumStorage, projectId: string, lessonId: string, options?: ProduceLessonOptions): Promise<ProduceLessonResult>;
+/**
+ * Batch production orchestrator supporting Lesson-by-Lesson (Strategy A) or Artifact-by-Artifact (Strategy B) execution.
+ */
+declare function produceBatchLessons(storage: ICurriculumStorage, projectId: string, lessonIds: string[], options?: ProduceLessonOptions): Promise<{
+    totalLessons: number;
+    completedLessons: string[];
+    pausedLessonId?: string;
+    report: ProjectStatusReport;
+}>;
+
+type ArtifactType = 'lesson' | 'slide' | 'act' | 'quiz' | 'guide' | 'handout' | 'worksheet' | 'rubric' | 'ext' | 'glossary' | 'codelab' | 'bom' | 'exit_ticket' | 'tiered_practice' | 'choice_board' | 'science_lab' | 'task_cards' | 'station_rotation' | 'bell_ringer' | 'review_game' | 'graphic_organizer';
+type ScaffoldingLevel = 'foundation' | 'balanced' | 'advanced';
+interface SingleArtifactRequest {
+    artifactType: ArtifactType;
+    topic: string;
+    lessonId?: string;
+    lessonTitle?: string;
+    pedagogy?: '5e' | 'edp' | 'pbl' | 'general';
+    targetAge?: string;
+    scaffoldingLevel?: ScaffoldingLevel;
+    hardwarePlatform?: string[];
+    contextSot?: {
+        framework?: string;
+        learnerProfile?: string;
+        lessonPlan?: string;
+        handout?: string;
+    };
+    options?: {
+        model?: string;
+        temperature?: number;
+        openrouterKey?: string;
+        alibabaKey?: string;
+        deepseekKey?: string;
+        geminiKey?: string;
+        nvidiaKey?: string;
+        openaiKey?: string;
+        anthropicKey?: string;
+    };
+    onChunk?: (chunk: string, type: 'content' | 'thought') => void;
+}
+interface SingleArtifactResult {
+    artifactType: ArtifactType;
+    filename: string;
+    content: string;
+    persona: string;
+    thought?: string;
+}
+/**
+ * Maps artifact type to default canonical filename and responsible agent persona
+ */
+declare function getArtifactMetadata(type: ArtifactType, lessonId?: string): {
+    filename: string;
+    persona: string;
+    templateFile: string;
+};
+/**
+ * Universal Single Artifact Generator Service for all 21 Pedagogical JTBD Artifacts
+ */
+declare function generateSingleArtifact(req: SingleArtifactRequest): Promise<SingleArtifactResult>;
+
+interface ProjectCreationPayload {
+    projectName: string;
+    projectCode: string;
+    coreObjective: string;
+    topic: string;
+    targetAge: string;
+    pedagogy: '5e' | 'edp' | 'pbli' | string;
+    hardwarePlatform: string[];
+    artifactScope: string[];
+    context?: 'school' | 'corporate' | 'community' | 'competition' | string;
+    depth?: 'remember' | 'understand' | 'apply' | 'evaluate' | 'create' | string;
+    tone?: 'friendly' | 'academic' | 'inspiring' | string;
+    language?: 'vi' | 'en' | string;
+    specialRequirements?: string;
+}
+interface ProjectClarification {
+    question: string;
+    missingField: keyof ProjectCreationPayload | string;
+    options: string[];
+}
+interface ProjectIntentAnalysisResult {
+    status: 'READY' | 'NEEDS_CLARIFICATION';
+    message: string;
+    payload?: ProjectCreationPayload;
+    clarification?: ProjectClarification;
+}
+/**
+ * Slugifies a project name into standard kebab-case project code.
+ * Ensures uniqueness against any existing project codes.
+ */
+declare function slugifyProjectName(name: string, existingCodes?: string[]): string;
+/**
+ * Analyzes natural language project creation request and extracts structured parameters or clarification questions.
+ */
+declare function analyzeProjectCreationIntent(userPrompt: string, currentContext?: Record<string, any>): Promise<ProjectIntentAnalysisResult>;
+/**
+ * Initializes a new course project and writes initial SOT files into storage.
+ */
+declare function initializeProjectInStorage(storage: ICurriculumStorage, payload: ProjectCreationPayload): Promise<{
+    projectId: string;
+    filesCreated: string[];
+}>;
+/**
+ * Converts a Project Roadmap JSON into a standardized ProjectCreationPayload.
+ */
+declare function parseRoadmapJsonToProjectPayload(roadmapJson: any): ProjectCreationPayload;
+/**
+ * Ingests a Project Graph JSON (Architecture, Features, Implementation symbols) as a Reference Resource in the project SOT.
+ */
+declare function ingestProjectGraphIntoProject(storage: ICurriculumStorage, projectId: string, graphJson: any): Promise<{
+    success: boolean;
+    filesCreated: string[];
+    summary: string;
+}>;
+
+interface SlashCommandDefinition {
+    id: string;
+    command: string;
+    label: string;
+    description: string;
+    category: 'workflow' | 'audit' | 'knowledge' | 'specs';
+}
+declare const CURRICULUM_SLASH_COMMANDS: SlashCommandDefinition[];
+interface ExecuteCommandResult {
+    success: boolean;
+    command: string;
+    actionTaken: string;
+    artifactPath?: string;
+    content?: string;
+    message: string;
+}
+/**
+ * Executes a curriculum-kit slash command against the given project storage.
+ */
+declare function executeCurriculumCommand(storage: ICurriculumStorage, projectId: string, command: string, payload?: {
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    projectName?: string;
+    pedagogy?: string;
+}): Promise<ExecuteCommandResult>;
+
+/**
+ * Deterministic Pipeline Runner (Parity with LangGraph unit_loop_node & ARTIFACT_EXECUTION_ORDER)
+ *
+ * Enforces the strict sequential waterfall for lesson production:
+ * 1. Step 1: LESSON (5E Master Plan — The Artifact Contract)
+ * 2. Step 2: ACT (STEM Lab Operations bound to LESSON contract)
+ * 3. Step 3: QUIZ (Diagnostic & Summative Quizzes bound to LESSON evidence)
+ * 4. Step 4: SLIDE (Marp Visual Slides bound to 5E Phases)
+ * 5. Step 5: SATELLITES (GUIDE, WKS, HANDOUT, EXT)
+ */
+interface ArtifactProductionSpec {
+    artifactType: 'LESSON' | 'ACT' | 'QUIZ' | 'SLIDE' | 'GUIDE' | 'WKS' | 'HANDOUT' | 'EXT' | 'MEDIA_SCRIPT';
+    assignedPersona: string;
+    isContractRoot: boolean;
+    requiresPriorLesson: boolean;
+}
+declare const ARTIFACT_EXECUTION_ORDER: ArtifactProductionSpec[];
+interface PipelineExecutionProgress {
+    lessonId: string;
+    currentStepIndex: number;
+    totalSteps: number;
+    activeArtifact: string;
+    assignedPersona: string;
+    completedArtifacts: string[];
+    pendingArtifacts: string[];
+    status: 'IDLE' | 'IN_PROGRESS' | 'AWAITING_APPROVAL' | 'COMPLETED' | 'ERROR';
+    error?: string;
+}
+declare class DeterministicPipelineRunner {
+    /**
+     * Determine what artifacts need to be produced next for a lesson, honoring the strict dependency order.
+     */
+    static getNextProductionTarget(lessonId: string, existingArtifacts: string[], scopedArtifactTypes?: string[]): {
+        nextArtifact: ArtifactProductionSpec | null;
+        isLessonComplete: boolean;
+        parallelQueue: string[];
+        progress: PipelineExecutionProgress;
+    };
+}
+
+interface LayerPrefillOptions {
+    action?: 'prefill' | 'research';
+    targetLayer?: number;
+    accumulatedData?: Record<string, any>;
+    apiKeys?: Record<string, string>;
+    liveSearchConfig?: Record<string, boolean>;
+    stream?: boolean;
+}
+interface PreliminaryResearchResult {
+    groundTruthSummary: string;
+    hardwareVersion: string;
+    ideVersion: string;
+    activeLibraries: string[];
+    technicalGotchas: string[];
+}
+interface LayerPrefillResult {
+    success: boolean;
+    targetLayer?: number;
+    parsedResponse?: any;
+    research?: PreliminaryResearchResult;
+    rawText?: string;
+}
+type LayerChunkCallback = (chunk: string, type: 'thought' | 'content') => void;
+/**
+ * Robust JSON extraction and repair helper
+ */
+declare function safeParseJson<T = any>(rawText: string | null): T | null;
+/**
+ * Multi-tiered resilient streaming inference helper for wizard layers.
+ */
+declare function streamLLMWithFallback(systemPrompt: string, userPrompt: string, apiKeys?: Record<string, string>, onChunk?: LayerChunkCallback): Promise<string | null>;
+/**
+ * Conducts preliminary ecosystem research for a course project.
+ */
+declare function conductPreliminaryResearch(options: LayerPrefillOptions, onChunk?: LayerChunkCallback): Promise<PreliminaryResearchResult>;
+/**
+ * Executes concentric 3-layer drill-down prefill inference with live reasoning stream.
+ */
+declare function streamLayerPrefillWithFallback(options: LayerPrefillOptions, onChunk?: LayerChunkCallback): Promise<LayerPrefillResult>;
+
+/**
+ * Curriculum Planner — turns a domain planning graph + constraints into a
+ * validated CurriculumPlan (planner outputs [1]-[7] from the design doc).
+ *
+ * Deterministic-first: LLM is optional and only used for prose objectives via
+ * the `llmFn` hook. Packing, depth and prereq/scaffold decisions are pure
+ * functions — testable, replayable, no silent fallbacks.
+ */
+interface PlannerLlmFn {
+    (systemPrompt: string, userPrompt: string): Promise<string>;
+}
+interface PlanOptions {
+    constraints: PlanConstraints;
+    translation?: TranslationPolicy;
+    /** Optional LLM for prose objectives; absent => deterministic templates. */
+    llmFn?: PlannerLlmFn;
+}
+interface PlanResult {
+    plan: CurriculumPlan;
+    warnings: string[];
+}
+/**
+ * Normalize any accepted input shape into a PlanningGraph.
+ * Accepted: CurriculumFeed v2 (learning_nodes), knowledge_graph (concepts),
+ * AssembledRoadmap (phases/milestones), raw project_graph (features/steps),
+ * hybrid (concepts + features/roadmap + links). Throws on unusable input.
+ */
+declare function normalizePlanningGraph(raw: unknown): PlanningGraph;
+declare function assertAcyclic(nodes: PlanningNode[], edges: DependencyEdge[]): void;
+declare function topoSort(nodes: PlanningNode[], edges: DependencyEdge[]): string[];
+interface PackingSpec {
+    contentBudget: number;
+    overheadMinutes: number;
+    sessionDurationMinutes: number;
+}
+declare function computePackingSpec(constraints: PlanConstraints): PackingSpec;
+declare function buildCurriculumPlan(rawGraph: unknown, options: PlanOptions): Promise<PlanResult>;
+/** Extract the machine-readable slice the LESSON agent consumes for one session. */
+declare function extractSessionSlice(plan: CurriculumPlan, lessonCode: string): CurriculumPlan['sessions'][number];
+/** Compact plan-slice context block for LESSON/satellite prompts (activity design inputs). */
+declare function buildSessionSliceContext(plan: CurriculumPlan, lessonCode: string): string;
+
+interface ProjectionMeta {
+    courseName: string;
+    shortDescription?: string;
+}
+declare function renderFrameworkFromPlan(plan: CurriculumPlan, meta: ProjectionMeta): string;
+/** Extract the glossary scope (terms per session) the EXPOSITION service consumes. */
+declare function glossaryTermsForSession(plan: CurriculumPlan, lessonCode: string): string[];
+
+/**
+ * KNOWLEDGE_EXPOSITION service — canonical knowledge reference per session,
+ * generated ON DEMAND after framework approval (design doc: option b).
+ *
+ * Guarantees:
+ *  - fail-closed: refuses without approval.status === 'approved'
+ *  - hash invalidation: regenerates when plan_hash changed after approval
+ *  - scope-locked: covers exactly the session's nodes/keywords/depths
+ *  - student-facing: no teacher-only content (LESSON owns activities)
+ */
+interface ExpositionLlmFn {
+    (systemPrompt: string, userPrompt: string): Promise<string>;
+}
+interface ExpositionStorage {
+    readArtifact(projectId: string, relPath: string): Promise<string | null>;
+    saveArtifact(projectId: string, relPath: string, content: string): Promise<void>;
+}
+declare const EXPOSITION_REL: (lessonCode: string) => string;
+declare class ExpositionApprovalError extends Error {
+    constructor(message: string);
+}
+/** Determine whether an existing EXPOSITION can be reused for this lesson. */
+declare function isExpositionFresh(existing: string | null, plan: CurriculumPlan, lessonCode: string): boolean;
+interface GenerateExpositionOptions {
+    projectId: string;
+    lessonCode: string;
+    plan: CurriculumPlan;
+    glossary: Array<{
+        term: string;
+        definition?: string;
+        example?: string;
+    }>;
+    llmFn: ExpositionLlmFn;
+    storage: ExpositionStorage;
+    gates?: ResolvedGateSettings;
+}
+interface ExpositionResult {
+    relPath: string;
+    content: string;
+    reused: boolean;
+    gateMode: 'OFF' | 'LLM_JUDGE' | 'HITL';
+}
+/**
+ * Generate (or reuse) the KNOWLEDGE_EXPOSITION for one lesson.
+ * Throws ExpositionApprovalError when the plan is not approved or approval
+ * hash mismatches the current plan — callers must NOT proceed to LESSON.
+ */
+declare function ensureKnowledgeExposition(options: GenerateExpositionOptions): Promise<ExpositionResult>;
+/** Build a compact exposition context block for LESSON / satellite prompts. */
+declare function buildExpositionContext(expositionContent: string, maxChars?: number): string;
+/** Integrity hash helper for cache bookkeeping. */
+declare function expositionCacheKey(planHash: string, lessonCode: string): string;
+
+/**
+ * End-to-end helper for the produce flow: read plan + glossary from SOT
+ * storage, ensure approval, generate/reuse the EXPOSITION, return a compact
+ * context block. Returns null when no plan exists (legacy flow) — callers
+ * render that state explicitly in telemetry, never silently.
+ */
+declare function ensureExpositionForLesson(storage: ICurriculumStorage, projectId: string, lessonCode: string, options?: {
+    gates?: ResolvedGateSettings;
+    force?: boolean;
+}): Promise<{
+    relPath: string;
+    context: string;
+    reused: boolean;
+} | null>;
+
+/**
+ * Translation policy resolver — decides which artifacts need a translated copy
+ * at which point, per the plan's translation policy. Composer executes the
+ * actual translation jobs; the kit owns the policy decision (pure function).
+ *
+ * Policy semantics (approved design D5):
+ *  - after_artifact: every artifact gets translated as soon as it passes its gate
+ *  - end_of_unit: artifacts of a unit are translated when the unit's last lesson is done
+ *  - at_publish: nothing translates until explicit publish — recommended default
+ */
+type TranslationTrigger = 'after_artifact' | 'end_of_unit' | 'at_publish';
+interface TranslationTarget {
+    /** Artifact-relative path of the SOURCE (always English). */
+    sourceRelPath: string;
+    /** Where the translated copy belongs (e.g. _i18n/vi/...). */
+    targetRelPath: string;
+    targetLanguage: string;
+    trigger: TranslationTrigger;
+    /** Unit code for end_of_unit grouping; null for course-wide artifacts. */
+    unitId: string | null;
+}
+declare function resolveTranslationTargets(plan: CurriculumPlan, knownArtifactPaths: string[]): TranslationTarget[];
+/** Should this target be translated NOW given the trigger and current state? */
+declare function isTranslationDue(target: TranslationTarget, context: {
+    completedLessonsByUnit: Record<string, number>;
+    totalLessonsByUnit: Record<string, number>;
+    publishRequested: boolean;
+}): boolean;
+
+/**
+ * Curriculum OS - Standardized Error Taxonomy & Traceability System
+ *
+ * Provides typed, structured, and traceable error codes for all pipeline failures,
+ * API exceptions, safeguard blocks, and contract violations.
+ */
+type CurriculumErrorCode = 'ERR_AI_NO_API_KEY' | 'ERR_AI_RATE_LIMIT' | 'ERR_AI_AUTH_FAILED' | 'ERR_AI_NETWORK_TIMEOUT' | 'ERR_AI_RESPONSE_MALFORMED' | 'ERR_AI_ALL_PROVIDERS_FAILED' | 'ERR_SOT_MISSING' | 'ERR_SOT_INVALID_SCHEMA' | 'ERR_TASK_GATE_BLOCKED' | 'ERR_METERED_LIMIT_EXCEEDED' | 'ERR_SCHEMA_CONTRACT_VIOLATION' | 'ERR_STORAGE_IO_FAILED';
+interface CurriculumErrorDetail {
+    errorCode: CurriculumErrorCode;
+    agent?: string;
+    artifactType?: string;
+    lessonId?: string;
+    provider?: string;
+    statusCode?: number;
+    message: string;
+    suggestedAction: string;
+    retryable: boolean;
+    timestamp: string;
+    rawError?: string;
+}
+declare class CurriculumError extends Error {
+    readonly detail: CurriculumErrorDetail;
+    constructor(detail: Omit<CurriculumErrorDetail, 'timestamp'>);
+    get errorCode(): CurriculumErrorCode;
+    get retryable(): boolean;
+    get suggestedAction(): string;
+    toJSON(): CurriculumErrorDetail;
+}
+/**
+ * Helper to build standardized AI inference errors
+ */
+declare function createAiInferenceError(params: {
+    errorCode: CurriculumErrorCode;
+    message: string;
+    provider?: string;
+    statusCode?: number;
+    agent?: string;
+    artifactType?: string;
+    lessonId?: string;
+    rawError?: any;
+    suggestedAction?: string;
+    retryable?: boolean;
+}): CurriculumError;
+
+/**
+ * Academic Quality & Pedagogical Verification Types
+ */
+type AcademicDimension = 'CONSTRUCTIVE_ALIGNMENT' | 'BLOOM_PROGRESSION' | '5E_INSTRUCTIONAL_FIDELITY' | 'MISCONCEPTION_RIGOR' | 'TECHNICAL_AUTHENTICITY' | 'CROSS_ARTIFACT_ZERO_DRIFT';
+type FindingSeverity = 'CRITICAL' | 'MAJOR' | 'MINOR';
+interface AcademicAuditFinding {
+    id: string;
+    dimension: AcademicDimension;
+    severity: FindingSeverity;
+    title: string;
+    description: string;
+    remediationAdvice: string;
+    affectedElement?: string;
+}
+interface DimensionScore {
+    score: number;
+    weight: number;
+    passed: boolean;
+    strengths: string[];
+    findings: AcademicAuditFinding[];
+}
+interface ComprehensiveAcademicReport {
+    timestamp: string;
+    targetId: string;
+    targetType: 'LESSON' | 'QUIZ' | 'ACT' | 'SLIDE' | 'BUNDLE' | 'SOT_CLUSTER';
+    overallScore: number;
+    passed: boolean;
+    verdict: 'EXEMPLARY' | 'ACADEMICALLY_SOUND' | 'NEEDS_PEDAGOGICAL_REFINEMENT' | 'REJECTED';
+    summary: string;
+    dimensionScores: {
+        constructiveAlignment: DimensionScore;
+        bloomProgression: DimensionScore;
+        fiveEFidelity: DimensionScore;
+        misconceptionRigor: DimensionScore;
+        technicalAuthenticity: DimensionScore;
+        crossArtifactZeroDrift: DimensionScore;
+    };
+    criticalFindingsCount: number;
+    allFindings: AcademicAuditFinding[];
+    actionablePromptGuidance: string[];
+}
+
+/**
+ * 🛠️ Deterministic Structural & Contract Linter
+ * Strict rule-based checks: Schema completeness, Zero-drift ID alignment,
+ * format sanity, and structural safety rules.
+ *
+ * ⛔ DOES NOT do regex-based semantic parsing or fake semantic understanding.
+ * All semantic, cognitive, and pedagogical evaluations are delegated to LLM-as-a-Judge.
+ */
+declare class DeterministicStructuralLinter {
+    /**
+     * Validates structural invariants across a complete lesson bundle.
+     */
+    static lintBundle(input: {
+        lesson: LessonPlan;
+        quiz?: DiagnosticQuizInput;
+        activity?: ActivityLab;
+        slides?: SlideDeck;
+        codeLab?: CodeLab;
+    }): {
+        passed: boolean;
+        structuralScore: number;
+        findings: AcademicAuditFinding[];
+        strengths: string[];
+    };
+}
+
+interface AuditBundleInput {
+    lesson: LessonPlan;
+    quiz?: DiagnosticQuizInput;
+    activity?: ActivityLab;
+    slides?: SlideDeck;
+    codeLab?: CodeLab;
+    modelOptions?: ModelResolutionOptions;
+    executeLLMJudge?: boolean;
+}
+declare class AcademicAuditor {
+    /**
+     * Evaluates a complete lesson bundle.
+     * Step 1 (Deterministic): Fast structural, contract, schema, and safety linting.
+     * Step 2 (Semantic LLM-as-a-Judge): Deep pedagogical, cognitive (Bloom), and misconception analysis with live frontier LLM.
+     */
+    static auditLessonBundle(input: AuditBundleInput): Promise<ComprehensiveAcademicReport>;
+}
+
+declare const BLOOM_ACTION_VERBS: {
+    remember: string[];
+    understand: string[];
+    apply: string[];
+    analyze: string[];
+    evaluate: string[];
+    create: string[];
+};
+declare class BloomTaxonomyEvaluator {
+    /**
+     * Audits a LessonPlan for Bloom taxonomy fidelity and cognitive scaffolding.
+     */
+    static evaluateLesson(lesson: LessonPlan): DimensionScore;
+    /**
+     * Audits a Diagnostic Quiz for true cognitive depth matching declared Bloom levels.
+     */
+    static evaluateQuiz(quiz: DiagnosticQuiz): DimensionScore;
+}
+
+declare class CrossArtifactDriftEvaluator {
+    /**
+     * Audits consistency, metadata synchronization, and zero-drift across all artifacts in a lesson bundle.
+     */
+    static evaluateBundle(lesson: LessonPlan, quiz?: DiagnosticQuiz, activity?: ActivityLab, slides?: SlideDeck): DimensionScore;
+}
+
+declare class ConstructiveAlignmentEvaluator {
+    /**
+     * Evaluates constructive alignment within a LessonPlan and across its satellite artifacts.
+     */
+    static evaluateLesson(lesson: LessonPlan, quiz?: DiagnosticQuiz, activity?: ActivityLab): DimensionScore;
+}
+
+declare class FiveEInstructionalEvaluator {
+    /**
+     * Evaluates the pedagogical structure of a Lesson Plan against the 5E Inquiry Model.
+     */
+    static evaluateLesson(lesson: LessonPlan): DimensionScore;
+}
+
+declare class CodeHardwareFeasibilityEvaluator {
+    /**
+     * Audits technical accuracy, code syntax sanity, and hardware circuit safety.
+     */
+    static evaluateTechnicalFeasibility(lesson?: LessonPlan, codeLab?: CodeLab, activity?: ActivityLab): DimensionScore;
+}
+
+declare class MisconceptionEvaluator {
+    /**
+     * Audits the psychometric and pedagogical rigor of diagnostic questions and their distractors.
+     */
+    static evaluateQuiz(quiz: DiagnosticQuiz): DimensionScore;
+}
+
+export { ARTIFACT_EXECUTION_ORDER, type AcademicAuditFinding, AcademicAuditor, type AcademicDimension, ActivityLab, type ArtifactProductionSpec, type ArtifactType, type AuditBundleInput, BLOOM_ACTION_VERBS, BloomTaxonomyEvaluator, type BuildContextOptions, CURRICULUM_SLASH_COMMANDS, CodeHardwareFeasibilityEvaluator, CodeLab, type ComprehensiveAcademicReport, ConstructiveAlignmentEvaluator, CrossArtifactDriftEvaluator, CurriculumError, type CurriculumErrorCode, type CurriculumErrorDetail, CurriculumPlan, DependencyEdge, DeterministicPipelineRunner, DeterministicStructuralLinter, DiagnosticQuiz, DiagnosticQuizInput, type DimensionScore, EXPOSITION_REL, type ExecuteCommandResult, ExpositionApprovalError, type ExpositionLlmFn, type ExpositionResult, type ExpositionStorage, type FindingSeverity, FiveEInstructionalEvaluator, type FrameworkLintFinding, type FrameworkLintReport, FrameworkPack, type GenerateExpositionOptions, ICurriculumStorage, type LayerChunkCallback, type LayerPrefillOptions, type LayerPrefillResult, LessonPlan, MisconceptionEvaluator, ModelResolutionOptions, type PackingSpec, type PedagogicalModel, type PipelineExecutionProgress, PlanConstraints, type PlanOptions, type PlanResult, type PlannerLlmFn, PlanningGraph, PlanningNode, type PreliminaryResearchResult, type ProduceLessonOptions, type ProduceLessonResult, type ProjectBriefingData, type ProjectClarification, type ProjectCreationPayload, type ProjectIntentAnalysisResult, ProjectStatusReport, type ProjectionMeta, QualityAuditReport, ResolvedGateSettings, type ScaffoldingLevel, type SingleArtifactRequest, type SingleArtifactResult, type SlashCommandDefinition, SlideDeck, SmartResumeContext, TranslationPolicy, type TranslationTarget, type TranslationTrigger, analyzeProjectCreationIntent, assertAcyclic, auditQualityReport, buildCurriculumContext, buildCurriculumPlan, buildExpositionContext, buildSessionSliceContext, computePackingSpec, conductPreliminaryResearch, createAiInferenceError, detectProjectPedagogy, ensureExpositionForLesson, ensureKnowledgeExposition, executeCurriculumCommand, expositionCacheKey, extractScopeSequenceRows, extractSessionSlice, generatePhase1SotArtifacts, generatePhase2SotArtifacts, generateSingleArtifact, getArtifactMetadata, getLessonMetadata, getProjectArtifactScope, getProjectStatusReport, getSmartResumeContext, glossaryTermsForSession, ingestProjectGraphIntoProject, initializeProjectInStorage, isExpositionFresh, isTranslationDue, lintCurriculumFramework, loadCurriculumTemplate, loadSotTemplate, normalizePlanningGraph, parseRoadmapJsonToProjectPayload, produceBatchLessons, produceSingleLesson, renderFrameworkFromPlan, resolveTranslationTargets, safeParseJson, slugifyProjectName, streamLLMWithFallback, streamLayerPrefillWithFallback, topoSort };