@studiolxd/lxd-cli 0.1.0-next.0

package/dist/cli/index.js

@@ -0,0 +1,2763 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { realpathSync } from "node:fs";
+
+// package.json
+var package_default = {
+  name: "@studiolxd/lxd-cli",
+  version: "0.1.0-next.0",
+  description: "CLI-first authoring tool for AI-native elearning packages (agent-orchestrated, framework- and export-target-agnostic).",
+  type: "module",
+  license: "UNLICENSED",
+  engines: {
+    node: ">=20"
+  },
+  bin: {
+    lxd: "./dist/cli/index.js"
+  },
+  files: [
+    "dist",
+    "docs"
+  ],
+  publishConfig: {
+    access: "public",
+    tag: "next"
+  },
+  scripts: {
+    build: 'esbuild src/cli/index.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/cli/index.js --banner:js="#!/usr/bin/env node" && node scripts/copy-assets.mjs',
+    prepack: "npm run build",
+    prepublishOnly: "npm run typecheck && npm run lint && npm run test",
+    "verify:pack": "node scripts/verify-package.mjs",
+    dev: "tsx src/cli/index.ts",
+    typecheck: "tsc --noEmit",
+    lint: "eslint .",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  dependencies: {
+    "@clack/prompts": "^0.7.0",
+    ajv: "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    archiver: "^7.0.1",
+    commander: "^12.1.0",
+    pino: "^9.5.0",
+    "pino-pretty": "^13.0.0",
+    yaml: "^2.6.0"
+  },
+  devDependencies: {
+    "@types/archiver": "^6.0.3",
+    "@types/node": "^20.16.0",
+    "@typescript-eslint/eslint-plugin": "^8.13.0",
+    "@typescript-eslint/parser": "^8.13.0",
+    "@vitest/coverage-v8": "^2.1.4",
+    esbuild: "^0.24.0",
+    eslint: "^8.57.1",
+    "eslint-config-prettier": "^9.1.0",
+    prettier: "^3.3.3",
+    tsx: "^4.19.0",
+    typescript: "^5.6.3",
+    vitest: "^2.1.4"
+  }
+};
+
+// src/cli/commands/init.ts
+import { resolve as resolve2 } from "node:path";
+
+// src/core/project/store.ts
+import { mkdir, readFile, writeFile, readdir, access } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/core/model/index.ts
+var SIGNALS = [
+  "progress",
+  "score",
+  "completion",
+  "interaction",
+  "feedback",
+  "suspend"
+];
+var NAVIGATION = ["linear", "free", "guided"];
+var DESIGN_LEVELS = [
+  "brief",
+  "tokens",
+  "patterns",
+  "design-system",
+  "full-constraints"
+];
+var REPORTED_FIELDS = [
+  "completion",
+  "success",
+  "score",
+  "suspend_data",
+  "lesson_location"
+];
+var EXPORT_ADAPTERS_V1 = ["web", "scorm-1.2", "scorm-2004"];
+var SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+function isSlug(value) {
+  return SLUG_RE.test(value);
+}
+function withExperienceDefaults(exp) {
+  return {
+    ...exp,
+    required: exp.required ?? true,
+    weight: exp.weight ?? 1,
+    signals: exp.signals ?? []
+  };
+}
+
+// src/observability/logger.ts
+import pino from "pino";
+var REDACT_PATHS = [
+  "password",
+  "*.password",
+  "token",
+  "*.token",
+  "secret",
+  "*.secret",
+  "secrets",
+  "*.secrets",
+  "credential",
+  "*.credential",
+  "credentials",
+  "*.credentials",
+  "apiKey",
+  "*.apiKey",
+  "authorization",
+  "*.authorization"
+];
+function createLogger(opts = {}) {
+  const level = opts.level ?? process.env.LOG_LEVEL ?? "warn";
+  const redact = { paths: REDACT_PATHS, censor: "[REDACTED]" };
+  if (opts.pretty) {
+    return pino({
+      level,
+      redact,
+      transport: { target: "pino-pretty", options: { destination: 2 } }
+    });
+  }
+  return pino({ level, redact }, pino.destination(2));
+}
+var logger = createLogger({ pretty: Boolean(process.stderr.isTTY) });
+
+// src/core/project/store.ts
+function assertSafeExperienceId(id) {
+  if (!isSlug(id)) {
+    throw new Error(`Unsafe experience id "${id}": must be a slug ([a-z0-9-]) \u2014 no path separators or traversal`);
+  }
+}
+var PATHS = {
+  pkg: ["package.elearning.yml"],
+  design: ["design", "design-direction.yml"],
+  experiencesDir: ["experiences"],
+  tracking: ["tracking", "tracking.yml"],
+  export: ["export", "export.config.yml"],
+  manifest: [".elearning", "manifest.lock"]
+};
+function at(dir, parts) {
+  return join(dir, ...parts);
+}
+async function writeYaml(path, data) {
+  await mkdir(join(path, ".."), { recursive: true });
+  await writeFile(path, stringifyYaml(data), "utf8");
+}
+async function readYaml(path) {
+  return parseYaml(await readFile(path, "utf8"));
+}
+async function initProject(dir, opts) {
+  for (const sub of ["design", "experiences", "tracking", "export", ".elearning", "generated", ".agent"]) {
+    await mkdir(join(dir, sub), { recursive: true });
+  }
+  const skeleton = {
+    id: opts.id,
+    schemaVersion: "1",
+    experienceRefs: []
+  };
+  await writeFile(at(dir, PATHS.pkg), stringifyYaml(skeleton), "utf8");
+  const manifest = { cliVersion: "0.0.0" };
+  await writeYaml(at(dir, PATHS.manifest), manifest);
+}
+async function saveProject(dir, project) {
+  await mkdir(dir, { recursive: true });
+  await writeFile(at(dir, PATHS.pkg), stringifyYaml(project.package), "utf8");
+  await writeYaml(at(dir, PATHS.design), project.design);
+  await writeYaml(at(dir, PATHS.tracking), project.tracking);
+  await writeYaml(at(dir, PATHS.export), project.export);
+  await writeYaml(at(dir, PATHS.manifest), project.manifest);
+  const expDir = at(dir, PATHS.experiencesDir);
+  await mkdir(expDir, { recursive: true });
+  for (const exp of project.experiences) {
+    assertSafeExperienceId(exp.id);
+    await writeFile(join(expDir, `${exp.id}.yml`), stringifyYaml(exp), "utf8");
+  }
+  logger.debug({ dir, experiences: project.experiences.length }, "Saved project");
+}
+async function readPackage(dir) {
+  return readYaml(at(dir, PATHS.pkg));
+}
+async function packageExists(dir) {
+  try {
+    await access(at(dir, PATHS.pkg));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writePackage(dir, pkg) {
+  await mkdir(dir, { recursive: true });
+  await writeFile(at(dir, PATHS.pkg), stringifyYaml(pkg), "utf8");
+}
+async function writeDesign(dir, design) {
+  await writeYaml(at(dir, PATHS.design), design);
+}
+async function writeTracking(dir, tracking) {
+  await writeYaml(at(dir, PATHS.tracking), tracking);
+}
+async function writeExport(dir, exportConfig) {
+  await writeYaml(at(dir, PATHS.export), exportConfig);
+}
+async function writeExperienceFile(dir, exp) {
+  assertSafeExperienceId(exp.id);
+  const expDir = at(dir, PATHS.experiencesDir);
+  await mkdir(expDir, { recursive: true });
+  await writeFile(join(expDir, `${exp.id}.yml`), stringifyYaml(exp), "utf8");
+}
+async function loadProjectLenient(dir) {
+  const empty = {};
+  const pkg = await readPackage(dir).catch(
+    () => ({ id: "", schemaVersion: "1", experienceRefs: [] })
+  );
+  const design = await readYaml(at(dir, PATHS.design)).catch(() => empty);
+  const tracking = await readYaml(at(dir, PATHS.tracking)).catch(() => empty);
+  const exportConfig = await readYaml(at(dir, PATHS.export)).catch(() => empty);
+  const manifest = await readYaml(at(dir, PATHS.manifest)).catch(() => ({
+    cliVersion: "0.0.0"
+  }));
+  const experiences = [];
+  try {
+    const files = (await readdir(at(dir, PATHS.experiencesDir))).filter((f) => f.endsWith(".yml"));
+    for (const file of files) {
+      experiences.push(await readYaml(join(at(dir, PATHS.experiencesDir), file)));
+    }
+  } catch {
+  }
+  return { package: pkg, design, experiences, tracking, export: exportConfig, manifest };
+}
+
+// src/cli/context.ts
+import { resolve } from "node:path";
+function cwdOf(cmd) {
+  const opts = cmd.optsWithGlobals();
+  return resolve(opts.cwd ?? process.cwd());
+}
+
+// src/cli/commands/init.ts
+function register(program) {
+  program.command("init [dir]").description("Initialize a new elearning package project").option("--id <id>", "package id (slug)").action(async (dir, opts, cmd) => {
+    const base = resolve2(cwdOf(cmd), dir ?? ".");
+    await initProject(base, { id: opts.id ?? "my-package" });
+    console.log(`Initialized elearning package project at ${base}`);
+  });
+}
+
+// src/cli/commands/goal.ts
+function register2(program) {
+  program.command("goal").description("Set or show the learning goal").option("-g, --goal <text>", "the learning goal").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd);
+    const pkg = await readPackage(dir);
+    if (opts.goal === void 0) {
+      console.log(pkg.learningGoal ?? "(no learning goal set)");
+      return;
+    }
+    pkg.learningGoal = opts.goal;
+    await writePackage(dir, pkg);
+    console.log("Learning goal updated.");
+  });
+}
+
+// src/cli/commands/audience.ts
+function register3(program) {
+  program.command("audience").description("Set target audience, duration, context, constraints, and tone").option("-d, --description <text>", "audience description").option("-m, --duration <minutes>", "expected learning time in minutes").option("-c, --context <text>", "delivery context").option("-t, --tone <text>", "tone").action(
+    async (opts, cmd) => {
+      const dir = cwdOf(cmd);
+      const pkg = await readPackage(dir);
+      if (opts.description) pkg.audience = { ...pkg.audience, description: opts.description };
+      if (opts.duration) pkg.duration = { expectedMinutes: Number(opts.duration) };
+      if (opts.context) pkg.context = opts.context;
+      if (opts.tone) pkg.tone = opts.tone;
+      await writePackage(dir, pkg);
+      console.log("Audience/context updated.");
+    }
+  );
+}
+
+// src/core/model/structure.ts
+function structureCoversExperiences(structure, experienceRefs) {
+  const order = new Set(structure?.order ?? []);
+  return experienceRefs.every((id) => order.has(id));
+}
+function buildOrder(experienceRefs, existingOrder) {
+  const refSet = new Set(experienceRefs);
+  const kept = (existingOrder ?? []).filter((id) => refSet.has(id));
+  const keptSet = new Set(kept);
+  const appended = experienceRefs.filter((id) => !keptSet.has(id));
+  return [...kept, ...appended];
+}
+
+// src/cli/commands/structure.ts
+function register4(program) {
+  program.command("structure").description("Set package structure and navigation across experiences").option("-n, --navigation <mode>", `navigation mode (${NAVIGATION.join("|")})`).option("--order <ids...>", "explicit experience order").option("--sync", "reconcile order with current experiences (keep order, drop removed, append new)").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd);
+    const pkg = await readPackage(dir);
+    if (opts.navigation && !NAVIGATION.includes(opts.navigation)) {
+      console.error(`Invalid navigation mode: ${opts.navigation}. Use ${NAVIGATION.join("|")}.`);
+      process.exitCode = 1;
+      return;
+    }
+    const nav = opts.navigation ?? pkg.structure?.navigation ?? "linear";
+    let order = pkg.structure?.order ?? [];
+    if (opts.order) {
+      order = opts.order;
+    } else if (opts.sync || order.length === 0) {
+      order = buildOrder(pkg.experienceRefs ?? [], order);
+    }
+    pkg.structure = {
+      navigation: nav,
+      order,
+      ...pkg.structure?.sections ? { sections: pkg.structure.sections } : {}
+    };
+    await writePackage(dir, pkg);
+    console.log(`Structure updated (navigation: ${nav}, ${order.length} experience(s)).`);
+  });
+}
+
+// src/core/authoring/experience-builder.ts
+function buildExperience(a) {
+  return withExperienceDefaults({
+    id: a.id,
+    title: a.title ?? a.id,
+    learningPurpose: a.learningPurpose ?? "",
+    scenario: { summary: a.scenario ?? "" },
+    mechanicRef: a.mechanicRef,
+    feedback: { model: a.feedbackModel ?? "immediate" }
+  });
+}
+
+// src/cli/commands/experience.ts
+function register5(program) {
+  const experience = program.command("experience").description("Manage interactive experiences");
+  experience.command("add").description("Add an experience to the package").requiredOption("--id <id>", "experience id (slug)").option("--title <text>", "title").option("--purpose <text>", "learning purpose").option("--scenario <text>", "scenario summary").option("--mechanic <id>", "mechanic id").option("--feedback <model>", "feedback model", "immediate").action(
+    async (opts, cmd) => {
+      const dir = cwdOf(cmd.parent);
+      const exp = buildExperience({
+        id: opts.id,
+        title: opts.title,
+        learningPurpose: opts.purpose,
+        scenario: opts.scenario,
+        mechanicRef: opts.mechanic ?? "",
+        feedbackModel: opts.feedback
+      });
+      await writeExperienceFile(dir, exp);
+      const pkg = await readPackage(dir);
+      if (!pkg.experienceRefs.includes(exp.id)) pkg.experienceRefs.push(exp.id);
+      pkg.structure = {
+        navigation: pkg.structure?.navigation ?? "linear",
+        order: [.../* @__PURE__ */ new Set([...pkg.structure?.order ?? [], exp.id])]
+      };
+      await writePackage(dir, pkg);
+      console.log(`Added experience "${exp.id}".`);
+    }
+  );
+  experience.command("list").description("List experiences in the package").action(async (_opts, cmd) => {
+    const project = await loadProjectLenient(cwdOf(cmd.parent));
+    for (const e of project.experiences) console.log(`${e.id}	${e.title}	[${e.mechanicRef}]`);
+  });
+  experience.command("remove").description("Remove an experience reference from the package").requiredOption("--id <id>", "experience id").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd.parent);
+    const pkg = await readPackage(dir);
+    pkg.experienceRefs = pkg.experienceRefs.filter((r) => r !== opts.id);
+    if (pkg.structure) pkg.structure.order = pkg.structure.order.filter((r) => r !== opts.id);
+    await writePackage(dir, pkg);
+    console.log(`Removed experience ref "${opts.id}".`);
+  });
+}
+
+// src/mechanics/registry.ts
+import { readdir as readdir2, readFile as readFile2, access as access2 } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseYaml2 } from "yaml";
+
+// src/mechanics/plugins/branching-narrative.ts
+var branchingNarrativePlugin = {
+  mechanicId: "branching-narrative",
+  version: "0.1.0",
+  validate(experience) {
+    const exp = experience;
+    const inputs = exp.mechanicInputs ?? {};
+    const checks = [];
+    const hasNodes = Array.isArray(inputs.nodes) && inputs.nodes.length > 0;
+    checks.push({
+      ok: hasNodes,
+      message: hasNodes ? "branching-narrative has at least one node" : "branching-narrative requires at least one node in mechanicInputs.nodes"
+    });
+    const hasStart = typeof inputs.start === "string" && inputs.start.length > 0;
+    checks.push({
+      ok: hasStart,
+      message: hasStart ? "branching-narrative has a start node" : "branching-narrative requires mechanicInputs.start (the starting node id)"
+    });
+    return checks;
+  },
+  enrichHandoff(experience) {
+    const exp = experience;
+    return `Render experience "${exp.id}" as a branching narrative: track the visited path in suspend data and emit completion at terminal nodes.`;
+  }
+};
+
+// src/mechanics/plugins/index.ts
+var OFFICIAL_PLUGINS = [branchingNarrativePlugin];
+function loadOfficialPlugins() {
+  return OFFICIAL_PLUGINS;
+}
+
+// src/mechanics/registry.ts
+var HERE = dirname(fileURLToPath(import.meta.url));
+var MANIFEST_CANDIDATES = [
+  join2(HERE, "manifests"),
+  join2(HERE, "..", "mechanics", "manifests")
+];
+async function resolveManifestDir() {
+  for (const dir of MANIFEST_CANDIDATES) {
+    try {
+      await access2(dir);
+      return dir;
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadOfficialMechanics() {
+  const dir = await resolveManifestDir();
+  if (!dir) {
+    logger.warn({ candidates: MANIFEST_CANDIDATES }, "No mechanic manifests directory found");
+    return [];
+  }
+  const files = (await readdir2(dir)).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  const manifests = [];
+  for (const file of files.sort()) {
+    const raw = await readFile2(join2(dir, file), "utf8");
+    manifests.push(parseYaml2(raw));
+  }
+  logger.debug({ dir, count: manifests.length }, "Loaded official mechanics");
+  return manifests;
+}
+async function createMechanicRegistry(manifests, plugins) {
+  const all = manifests ?? await loadOfficialMechanics();
+  const pluginList = plugins ?? await loadOfficialPlugins();
+  const byId = new Map(all.map((m) => [m.id, m]));
+  const pluginById = new Map(pluginList.map((p) => [p.mechanicId, p]));
+  const get = (id) => {
+    const m = byId.get(id);
+    if (!m) throw new Error(`Unknown mechanic: "${id}". Available: ${[...byId.keys()].join(", ")}`);
+    return m;
+  };
+  return {
+    list: () => [...byId.values()],
+    has: (id) => byId.has(id),
+    get,
+    getPlugin: (id) => pluginById.get(id),
+    getResolved: (id) => ({ manifest: get(id), plugin: pluginById.get(id) })
+  };
+}
+
+// src/cli/commands/mechanic.ts
+function register6(program) {
+  const mechanic = program.command("mechanic").description("Browse available official mechanics");
+  mechanic.command("list").description("List available official mechanics").action(async () => {
+    const registry = await createMechanicRegistry();
+    for (const m of registry.list()) console.log(`${m.id}	${m.name}	(${m.category ?? "uncategorized"})`);
+  });
+  mechanic.command("show").description("Show a mechanic manifest").requiredOption("--id <id>", "mechanic id").action(async (opts) => {
+    const registry = await createMechanicRegistry();
+    console.log(JSON.stringify(registry.get(opts.id), null, 2));
+  });
+}
+
+// src/cli/commands/design.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+import { parse as parseYaml3 } from "yaml";
+
+// src/core/schema/loader.ts
+import { Ajv2020 } from "ajv/dist/2020.js";
+import addFormatsModule from "ajv-formats";
+
+// src/core/schema/package-spec.schema.json
+var package_spec_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/package-spec.schema.json",
+  title: "PackageSpec",
+  description: "Top-level elearning package. The package is the unit of delivery (FR-002); a single experience is never top-level.",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "schemaVersion",
+    "learningGoal",
+    "audience",
+    "duration",
+    "structure",
+    "experienceRefs",
+    "designRef",
+    "completionRules",
+    "trackingRef",
+    "exportRef"
+  ],
+  properties: {
+    id: { type: "string", pattern: "^[a-z0-9][a-z0-9-]*$" },
+    schemaVersion: { type: "string" },
+    learningGoal: { type: "string", minLength: 1 },
+    title: { type: "string" },
+    audience: {
+      type: "object",
+      additionalProperties: false,
+      required: ["description"],
+      properties: {
+        description: { type: "string", minLength: 1 },
+        priorKnowledge: { type: "string" },
+        roles: { type: "array", items: { type: "string" } }
+      }
+    },
+    duration: {
+      type: "object",
+      additionalProperties: false,
+      required: ["expectedMinutes"],
+      properties: {
+        expectedMinutes: { type: "number", exclusiveMinimum: 0 },
+        note: { type: "string" }
+      }
+    },
+    context: { type: "string" },
+    constraints: { type: "array", items: { type: "string" } },
+    tone: { type: "string" },
+    structure: {
+      type: "object",
+      additionalProperties: false,
+      required: ["navigation", "order"],
+      properties: {
+        navigation: { enum: ["linear", "free", "guided"] },
+        order: { type: "array", items: { type: "string" }, minItems: 1 },
+        sections: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "title", "experienceIds"],
+            properties: {
+              id: { type: "string" },
+              title: { type: "string" },
+              experienceIds: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    },
+    experienceRefs: {
+      type: "array",
+      minItems: 1,
+      items: { type: "string", description: "experience id (file in experiences/)" }
+    },
+    designRef: { type: "string" },
+    evaluationRules: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        assessed: { type: "boolean" },
+        scoreRules: { $ref: "#/$defs/scoreRules" },
+        criteria: { type: "array", items: { type: "string" } }
+      },
+      if: { properties: { assessed: { const: true } }, required: ["assessed"] },
+      then: { required: ["scoreRules"] }
+    },
+    completionRules: {
+      type: "object",
+      additionalProperties: false,
+      required: ["rule"],
+      properties: {
+        rule: { enum: ["all-required", "selected-required"] },
+        requiredExperienceIds: { type: "array", items: { type: "string" } }
+      },
+      if: { properties: { rule: { const: "selected-required" } } },
+      then: { required: ["requiredExperienceIds"] }
+    },
+    trackingRef: { type: "string" },
+    exportRef: { type: "string" },
+    assetRefs: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        scormLibraryVersion: { type: "string" },
+        scormSkillsSnapshot: {
+          type: "object",
+          additionalProperties: false,
+          properties: { version: { type: "string" }, ref: { type: "string" } }
+        },
+        cliVersion: { type: "string" }
+      }
+    }
+  },
+  $defs: {
+    scoreRules: {
+      type: "object",
+      additionalProperties: false,
+      required: ["method"],
+      properties: {
+        method: { enum: ["percentage", "points", "scaled"] },
+        passThreshold: { type: "number" },
+        max: { type: "number" }
+      }
+    }
+  }
+};
+
+// src/core/schema/experience.schema.json
+var experience_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/experience.schema.json",
+  title: "Experience",
+  description: "An interactive learning experience inside a package (FR-007). Exactly one mechanic (FR-010).",
+  type: "object",
+  additionalProperties: false,
+  required: ["id", "title", "learningPurpose", "scenario", "mechanicRef", "feedback"],
+  properties: {
+    id: { type: "string", pattern: "^[a-z0-9][a-z0-9-]*$" },
+    title: { type: "string", minLength: 1 },
+    learningPurpose: { type: "string", minLength: 1 },
+    scenario: {
+      type: "object",
+      additionalProperties: false,
+      required: ["summary"],
+      properties: {
+        summary: { type: "string", minLength: 1 },
+        context: { type: "string" },
+        roles: { type: "array", items: { type: "string" } }
+      }
+    },
+    mechanicRef: { type: "string", description: "MechanicManifest.id; MUST resolve in the mechanic registry" },
+    mechanicInputs: { type: "object", description: "MUST satisfy the mechanic manifest's requiredInputs" },
+    interfaceIntent: { type: "string" },
+    evaluation: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        assessed: { type: "boolean" },
+        scoreRules: {
+          type: "object",
+          additionalProperties: false,
+          required: ["method"],
+          properties: {
+            method: { enum: ["percentage", "points", "scaled"] },
+            passThreshold: { type: "number" },
+            max: { type: "number" }
+          }
+        },
+        criteria: { type: "array", items: { type: "string" } }
+      },
+      if: { properties: { assessed: { const: true } }, required: ["assessed"] },
+      then: { required: ["scoreRules"] }
+    },
+    feedback: {
+      type: "object",
+      additionalProperties: false,
+      required: ["model"],
+      properties: {
+        model: { enum: ["immediate", "delayed", "summary", "adaptive"] },
+        messages: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["on", "message"],
+            properties: {
+              on: { type: "string", description: "meaningful learner action" },
+              message: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    required: { type: "boolean", default: true, description: "counts toward package completion roll-up" },
+    weight: { type: "number", exclusiveMinimum: 0, default: 1 },
+    signals: {
+      type: "array",
+      description: "signals this experience emits (subset of the canonical signal set)",
+      items: { enum: ["progress", "score", "completion", "interaction", "feedback", "suspend"] },
+      uniqueItems: true
+    }
+  }
+};
+
+// src/core/schema/mechanic-manifest.schema.json
+var mechanic_manifest_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/mechanic-manifest.schema.json",
+  title: "MechanicManifest",
+  description: "Declarative, REQUIRED contract for an experience mechanic (FR-008a). Official assets authored by Studio LXD in v1. An optional code plugin (FR-008b) may supplement but never replaces this manifest.",
+  type: "object",
+  additionalProperties: false,
+  required: ["id", "name", "version", "description", "requiredInputs", "trackingContract"],
+  properties: {
+    id: { type: "string", pattern: "^[a-z0-9][a-z0-9-]*$" },
+    name: { type: "string" },
+    version: { type: "string" },
+    category: { type: "string" },
+    description: { type: "string", minLength: 1 },
+    requiredInputs: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["key", "type"],
+        properties: {
+          key: { type: "string" },
+          type: { enum: ["string", "number", "boolean", "array", "object"] },
+          description: { type: "string" },
+          required: { type: "boolean", default: true }
+        }
+      }
+    },
+    evaluationContract: {
+      type: "object",
+      description: "shape the experience's evaluation must satisfy when this mechanic is assessable",
+      properties: { assessable: { type: "boolean" } }
+    },
+    feedbackContract: {
+      type: "object",
+      description: "shape of feedback this mechanic expects"
+    },
+    trackingContract: {
+      type: "array",
+      description: "signals the mechanic is expected to emit",
+      items: { enum: ["progress", "score", "completion", "interaction", "feedback", "suspend"] },
+      uniqueItems: true
+    },
+    agentGuidance: {
+      type: "string",
+      description: "instructions injected into agent handoff materials for this mechanic"
+    },
+    pluginRef: {
+      type: "string",
+      description: "OPTIONAL reference to a code plugin implementing mechanic-plugin.contract.md (FR-008b)"
+    }
+  }
+};
+
+// src/core/schema/design-direction.schema.json
+var design_direction_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/design-direction.schema.json",
+  title: "DesignDirection",
+  description: "First-class, multi-level design model (FR-011/012/013). Package-level, shared by experiences. 'level' gates which inputs are expected.",
+  type: "object",
+  additionalProperties: false,
+  required: ["level"],
+  properties: {
+    level: { enum: ["brief", "tokens", "patterns", "design-system", "full-constraints"] },
+    brief: { type: "string" },
+    tone: { type: "string" },
+    tokens: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        colors: { type: "object", additionalProperties: { type: "string" } },
+        typography: { type: "object" },
+        spacing: { type: "object" },
+        density: { enum: ["compact", "comfortable", "spacious"] }
+      }
+    },
+    patterns: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        ui: { type: "array", items: { type: "string" } },
+        interaction: { type: "array", items: { type: "string" } },
+        componentUsage: { type: "array", items: { type: "string" } }
+      }
+    },
+    accessibility: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        considered: { type: "boolean" },
+        targets: { type: "array", items: { type: "string" }, description: "e.g., WCAG level chosen per project" },
+        notes: { type: "string" }
+      }
+    },
+    responsive: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        approach: { enum: ["mobile-first", "desktop-first", "fluid"] },
+        breakpoints: { type: "array", items: { type: "string" } }
+      }
+    },
+    animation: { type: "string" },
+    designSystemRefs: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["kind", "ref"],
+        properties: {
+          kind: { enum: ["url", "file"] },
+          ref: { type: "string" }
+        }
+      }
+    },
+    constraints: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        do: { type: "array", items: { type: "string" } },
+        dont: { type: "array", items: { type: "string" } },
+        implementation: { type: "array", items: { type: "string" } }
+      }
+    },
+    output: {
+      type: "array",
+      items: { type: "string" },
+      description: "e.g., light-mode, dark-mode, mobile-first, corporate, playful, minimal"
+    }
+  },
+  allOf: [
+    { if: { properties: { level: { const: "brief" } }, required: ["level"] }, then: { required: ["brief"] } },
+    { if: { properties: { level: { const: "tokens" } }, required: ["level"] }, then: { required: ["tokens"] } },
+    { if: { properties: { level: { const: "patterns" } }, required: ["level"] }, then: { required: ["patterns"] } },
+    { if: { properties: { level: { const: "design-system" } }, required: ["level"] }, then: { required: ["designSystemRefs"] } },
+    { if: { properties: { level: { const: "full-constraints" } }, required: ["level"] }, then: { required: ["constraints"] } }
+  ]
+};
+
+// src/core/schema/tracking-config.schema.json
+var tracking_config_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/tracking-config.schema.json",
+  title: "TrackingConfig",
+  description: "Two-level tracking (FR-027): per-experience signals + explicit package roll-up rules (FR-027a). The roll-up produces the single LMS-reported state (FR-027b).",
+  type: "object",
+  additionalProperties: false,
+  required: ["experienceSignals", "rollUp"],
+  properties: {
+    experienceSignals: {
+      type: "object",
+      description: "map of experienceId -> declared signals",
+      additionalProperties: {
+        type: "array",
+        items: { enum: ["progress", "score", "completion", "interaction", "feedback", "suspend"] },
+        uniqueItems: true
+      }
+    },
+    rollUp: {
+      type: "object",
+      additionalProperties: false,
+      required: ["completion", "score", "reportedFields"],
+      properties: {
+        completion: {
+          type: "object",
+          additionalProperties: false,
+          required: ["rule"],
+          properties: {
+            rule: { enum: ["all-required-complete", "selected-required-complete"] },
+            requiredExperienceIds: { type: "array", items: { type: "string" } }
+          },
+          if: { properties: { rule: { const: "selected-required-complete" } } },
+          then: { required: ["requiredExperienceIds"] }
+        },
+        score: {
+          type: "object",
+          additionalProperties: false,
+          required: ["rule"],
+          properties: {
+            rule: { enum: ["weighted-average", "final-assessment-only"] },
+            finalAssessmentExperienceId: { type: "string" }
+          },
+          if: { properties: { rule: { const: "final-assessment-only" } } },
+          then: { required: ["finalAssessmentExperienceId"] }
+        },
+        success: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            scoreThreshold: { type: "number" },
+            requireRequiredExperiencesComplete: { type: "boolean", default: true }
+          }
+        },
+        reportedFields: {
+          type: "array",
+          minItems: 1,
+          items: { enum: ["completion", "success", "score", "suspend_data", "lesson_location"] },
+          uniqueItems: true
+        }
+      }
+    }
+  }
+};
+
+// src/core/schema/export-config.schema.json
+var export_config_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/export-config.schema.json",
+  title: "ExportConfig",
+  description: "Adapter-driven export configuration (FR-022/024). adapterId is an open enum; unknown ids without an adapter must be reported clearly (FR-025).",
+  type: "object",
+  additionalProperties: false,
+  required: ["targets"],
+  properties: {
+    targets: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["adapterId"],
+        properties: {
+          adapterId: {
+            type: "string",
+            description: "v1 in-tree adapters: web | scorm-1.2 | scorm-2004. Open to future adapters (xapi, cmi5, ...).",
+            examples: ["web", "scorm-1.2", "scorm-2004"]
+          },
+          options: {
+            type: "object",
+            description: "Adapter-specific options, validated against the adapter's own option schema",
+            properties: {
+              identifier: { type: "string", description: "SCORM manifest identifier" },
+              masteryScore: { type: "number", description: "SCORM 1.2 mastery score / 2004 scaled passing score" },
+              title: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    framework: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        adapterId: { type: "string", examples: ["webcomponents"] },
+        options: { type: "object" }
+      }
+    }
+  }
+};
+
+// src/core/schema/validation-report.schema.json
+var validation_report_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://studiolxd.dev/lxd-cli/validation-report.schema.json",
+  title: "ValidationReport",
+  description: "Output of the validation subsystem (FR-032/033). Every check is actionable: it identifies what failed and where.",
+  type: "object",
+  additionalProperties: false,
+  required: ["checks", "summary"],
+  properties: {
+    checks: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id", "category", "status", "message"],
+        properties: {
+          id: { type: "string", description: "stable check id, e.g., 'learning-goal-present'" },
+          category: {
+            enum: ["instructional", "design", "accessibility", "technical", "tracking", "export", "maintainability", "portability"]
+          },
+          status: { enum: ["pass", "fail", "warn", "skip"] },
+          message: { type: "string" },
+          location: { type: "string", description: "artifact path / field pointer the result refers to" },
+          fix: { type: "string", description: "suggested remediation" }
+        }
+      }
+    },
+    summary: {
+      type: "object",
+      additionalProperties: false,
+      required: ["pass", "fail", "warn", "skip", "overall"],
+      properties: {
+        pass: { type: "integer", minimum: 0 },
+        fail: { type: "integer", minimum: 0 },
+        warn: { type: "integer", minimum: 0 },
+        skip: { type: "integer", minimum: 0 },
+        overall: { enum: ["pass", "fail"] }
+      }
+    },
+    generatedAt: { type: "string", format: "date-time" }
+  }
+};
+
+// src/core/schema/schemas.ts
+var SCHEMA_IDS = [
+  "package-spec",
+  "experience",
+  "mechanic-manifest",
+  "design-direction",
+  "tracking-config",
+  "export-config",
+  "validation-report"
+];
+var SCHEMAS = {
+  "package-spec": package_spec_schema_default,
+  experience: experience_schema_default,
+  "mechanic-manifest": mechanic_manifest_schema_default,
+  "design-direction": design_direction_schema_default,
+  "tracking-config": tracking_config_schema_default,
+  "export-config": export_config_schema_default,
+  "validation-report": validation_report_schema_default
+};
+
+// src/core/schema/loader.ts
+var addFormats = addFormatsModule;
+var SchemaValidator = class {
+  ajv;
+  compiled = /* @__PURE__ */ new Map();
+  constructor() {
+    this.ajv = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(this.ajv);
+    for (const id of SCHEMA_IDS) {
+      this.compiled.set(id, this.ajv.compile(SCHEMAS[id]));
+    }
+  }
+  /** Throws if the named schema failed to compile (used by contract tests). */
+  assertCompiled(id) {
+    if (!this.compiled.has(id)) {
+      throw new Error(`Schema not compiled: ${id}`);
+    }
+  }
+  validate(id, data) {
+    const fn = this.compiled.get(id);
+    if (!fn) {
+      throw new Error(`Unknown schema id: ${id}`);
+    }
+    const valid = fn(data);
+    return { valid, errors: valid ? [] : toIssues(fn.errors) };
+  }
+};
+function toIssues(errors) {
+  if (!errors) return [];
+  return errors.map((e) => ({
+    message: e.message ?? "invalid",
+    path: e.instancePath || "/",
+    keyword: e.keyword
+  }));
+}
+function createValidator() {
+  return new SchemaValidator();
+}
+
+// src/cli/commands/design.ts
+function register7(program) {
+  program.command("design").description("Define design direction (simple brief through full constraints) \u2014 CLI-first, no GUI").option("-l, --level <level>", `design level (${DESIGN_LEVELS.join("|")})`, "brief").option("-b, --brief <text>", "natural-language design brief").option("--tone <text>", "tone / visual personality").option("--a11y <targets...>", 'accessibility targets (e.g., "WCAG 2.1 AA")').option("--output <items...>", "output requirements (e.g., light-mode dark-mode mobile-first)").option("--from <file>", "load a full design-direction document (YAML/JSON) for advanced levels").action(
+    async (opts, cmd) => {
+      const dir = cwdOf(cmd);
+      let design;
+      if (opts.from) {
+        design = parseYaml3(await readFile3(resolve3(dir, opts.from), "utf8"));
+      } else {
+        design = { level: opts.level };
+        if (opts.brief) design.brief = opts.brief;
+        if (opts.tone) design.tone = opts.tone;
+        if (opts.a11y) design.accessibility = { considered: true, targets: opts.a11y };
+        if (opts.output) design.output = opts.output;
+      }
+      const result = createValidator().validate("design-direction", design);
+      if (!result.valid) {
+        console.error("Invalid design direction:");
+        for (const e of result.errors) console.error(`  ${e.path}: ${e.message}`);
+        process.exitCode = 1;
+        return;
+      }
+      await writeDesign(dir, design);
+      console.log(`Design direction set (level: ${String(design.level)}).`);
+    }
+  );
+}
+
+// src/cli/commands/evaluation.ts
+function register8(program) {
+  program.command("evaluation").description("Set evaluation, feedback, and completion rules").option("-c, --completion <rule>", "completion rule (all-required|selected-required)", "all-required").option("--assessed", "mark the package as assessed").option("--pass-threshold <n>", "passing score threshold").action(
+    async (opts, cmd) => {
+      const dir = cwdOf(cmd);
+      const pkg = await readPackage(dir);
+      pkg.completionRules = { rule: opts.completion };
+      if (opts.assessed) {
+        pkg.evaluationRules = {
+          assessed: true,
+          scoreRules: {
+            method: "percentage",
+            passThreshold: opts.passThreshold ? Number(opts.passThreshold) : 70
+          }
+        };
+      }
+      await writePackage(dir, pkg);
+      console.log("Evaluation/completion rules updated.");
+    }
+  );
+}
+
+// src/core/validation/tracking.ts
+function checkTrackingRollup(project) {
+  const tracking = project.tracking;
+  const rollUp = tracking.rollUp;
+  if (!rollUp) {
+    return { status: "fail", message: "No roll-up rules defined", location: "tracking.rollUp" };
+  }
+  if (!rollUp.reportedFields || rollUp.reportedFields.length === 0) {
+    return {
+      status: "fail",
+      message: "Roll-up declares no reported fields",
+      location: "tracking.rollUp.reportedFields"
+    };
+  }
+  const expIds = new Set(project.experiences.map((e) => e.id));
+  if (rollUp.completion?.rule === "selected-required-complete") {
+    const ids = rollUp.completion.requiredExperienceIds ?? [];
+    if (ids.length === 0) {
+      return {
+        status: "fail",
+        message: "selected-required-complete needs requiredExperienceIds",
+        location: "tracking.rollUp.completion.requiredExperienceIds"
+      };
+    }
+    const unknown = ids.find((id) => !expIds.has(id));
+    if (unknown) {
+      return {
+        status: "fail",
+        message: `Roll-up references unknown experience "${unknown}"`,
+        location: "tracking.rollUp.completion.requiredExperienceIds"
+      };
+    }
+  }
+  if (rollUp.score?.rule === "final-assessment-only") {
+    const id = rollUp.score.finalAssessmentExperienceId;
+    if (!id || !expIds.has(id)) {
+      return {
+        status: "fail",
+        message: "final-assessment-only needs a valid finalAssessmentExperienceId",
+        location: "tracking.rollUp.score.finalAssessmentExperienceId"
+      };
+    }
+  }
+  return { status: "pass", message: "Roll-up rules are coherent" };
+}
+
+// src/core/validation/export.ts
+var KNOWN_EXPORT_ADAPTERS = ["web", "scorm-1.2", "scorm-2004"];
+function checkExportTargets(project) {
+  const cfg = project.export;
+  const targets = cfg.targets ?? [];
+  if (targets.length === 0) {
+    return { status: "skip", message: "No export targets configured yet", location: "export.targets" };
+  }
+  const unknown = targets.find((t) => !t.adapterId || !KNOWN_EXPORT_ADAPTERS.includes(t.adapterId));
+  if (unknown) {
+    return {
+      status: "fail",
+      message: `Unknown export target "${unknown.adapterId ?? "(missing)"}". Known: ${KNOWN_EXPORT_ADAPTERS.join(", ")}`,
+      location: "export.targets"
+    };
+  }
+  return { status: "pass", message: "All export targets map to known adapters" };
+}
+
+// src/core/validation/design.ts
+var REQUIRED_BY_LEVEL = {
+  brief: "brief",
+  tokens: "tokens",
+  patterns: "patterns",
+  "design-system": "designSystemRefs",
+  "full-constraints": "constraints"
+};
+function checkDesign(project) {
+  const design = project.design;
+  const level = design.level;
+  if (!level) {
+    return { status: "skip", message: "No design level set", location: "design.level" };
+  }
+  const required = REQUIRED_BY_LEVEL[level];
+  if (required && !design[required]) {
+    return {
+      status: "fail",
+      message: `Design level "${level}" requires "${required}"`,
+      location: `design.${required}`
+    };
+  }
+  return { status: "pass", message: `Design direction is complete for level "${level}"` };
+}
+
+// src/core/validation/portability.ts
+var FRAMEWORK_TOKENS = ["react", "vue", "svelte", "angular", "solidjs", "preact"];
+var TARGET_TOKENS = ["scorm", "xapi", "cmi5"];
+function checkPortability(project) {
+  const blob = JSON.stringify({
+    pkg: project.package,
+    design: project.design,
+    experiences: project.experiences
+  }).toLowerCase();
+  const framework = FRAMEWORK_TOKENS.find((t) => blob.includes(`"${t}"`));
+  if (framework) {
+    return {
+      status: "warn",
+      message: `Spec references a specific framework ("${framework}") \u2014 keep spec artifacts framework-agnostic`,
+      fix: "Move framework-specific guidance into the framework adapter, not the package spec"
+    };
+  }
+  const target = TARGET_TOKENS.find((t) => blob.includes(`"${t}`));
+  if (target) {
+    return {
+      status: "warn",
+      message: `Spec references an export target ("${target}") outside the export config`,
+      fix: "Express target-specific needs via export configuration/adapters"
+    };
+  }
+  return { status: "pass", message: "Spec artifacts are not coupled to a specific framework or export target" };
+}
+
+// src/core/validation/maintainability.ts
+var IMPLEMENTATION_MARKERS = ["<script", "<!doctype", "</html>", "</body>"];
+function checkMaintainability(project) {
+  const blob = JSON.stringify({
+    pkg: project.package,
+    design: project.design,
+    experiences: project.experiences,
+    tracking: project.tracking
+  }).toLowerCase();
+  const marker = IMPLEMENTATION_MARKERS.find((m) => blob.includes(m));
+  if (marker) {
+    return {
+      status: "fail",
+      message: `Spec artifacts appear to embed generated implementation ("${marker}") \u2014 keep spec and generated/ separate`,
+      location: "experiences",
+      fix: "Keep markup/code in generated/, not in the YAML specification"
+    };
+  }
+  return { status: "pass", message: "Specification and generated implementation are kept separate" };
+}
+
+// src/core/validation/scorm-runtime.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join as join3, extname } from "node:path";
+var SCORM_TARGETS = ["scorm-1.2", "scorm-2004"];
+var SCAN_EXT = /* @__PURE__ */ new Set([".js", ".ts", ".mjs", ".cjs", ".html"]);
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", ".agent", "scorm-skills"]);
+var LMS_12 = /\b(LMSInitialize|LMSFinish|LMSCommit|LMSGetValue|LMSSetValue|LMSGetLastError|LMSGetErrorString|LMSGetDiagnostic)\b/;
+var API_ASSIGN = /\bwindow\.(API|API_1484_11)\s*=/;
+function isScormTargeted(project) {
+  const targets = project.export.targets ?? [];
+  return targets.some((t) => t.adapterId !== void 0 && SCORM_TARGETS.includes(t.adapterId));
+}
+function detectSignature(content) {
+  if (API_ASSIGN.test(content)) return "window.API assignment";
+  if (LMS_12.test(content)) return "custom SCORM 1.2 LMS* handler";
+  if (/\bInitialize\b/.test(content) && /\bTerminate\b/.test(content) && /\b(GetValue|SetValue)\b/.test(content)) {
+    return "custom SCORM 2004 API cluster (Initialize/Terminate/Get|SetValue)";
+  }
+  return null;
+}
+function* walk(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (EXCLUDE_DIRS.has(entry.name)) continue;
+      yield* walk(join3(dir, entry.name));
+    } else if (SCAN_EXT.has(extname(entry.name))) {
+      yield join3(dir, entry.name);
+    }
+  }
+}
+function checkScormRuntime(project, ctx) {
+  if (!ctx?.projectDir) return { status: "skip", message: "No project directory to scan" };
+  if (!isScormTargeted(project)) return { status: "skip", message: "No SCORM export target configured" };
+  const generatedDir = join3(ctx.projectDir, "generated");
+  if (!existsSync(generatedDir)) {
+    return { status: "skip", message: "No generated/ output to inspect yet" };
+  }
+  for (const file of walk(generatedDir)) {
+    const signature = detectSignature(readFileSync(file, "utf8"));
+    if (signature) {
+      const rel = file.slice(ctx.projectDir.length + 1);
+      return {
+        status: "fail",
+        message: `Custom SCORM runtime detected (${signature}) \u2014 integrate @studiolxd/scorm instead of hand-rolling a runtime`,
+        location: rel,
+        fix: "Use @studiolxd/scorm for all SCORM runtime interactions (see .agent/scorm-skills/)"
+      };
+    }
+  }
+  return { status: "pass", message: "No custom SCORM runtime in generated/ (uses @studiolxd/scorm)" };
+}
+
+// src/core/validation/engine.ts
+var CHECKS = [
+  {
+    id: "learning-goal-present",
+    category: "instructional",
+    run: (p) => p.package.learningGoal?.trim() ? ok("Learning goal is defined") : fail("Learning goal is missing", "package.learningGoal")
+  },
+  {
+    id: "audience-defined",
+    category: "instructional",
+    run: (p) => p.package.audience?.description?.trim() ? ok("Audience is defined") : fail("Target audience is not defined", "package.audience.description")
+  },
+  {
+    id: "duration-defined",
+    category: "instructional",
+    run: (p) => (p.package.duration?.expectedMinutes ?? 0) > 0 ? ok("Duration is defined") : fail("Expected learning time is not defined", "package.duration.expectedMinutes")
+  },
+  {
+    id: "structure-present",
+    category: "instructional",
+    run: (p) => (p.package.structure?.order?.length ?? 0) > 0 ? ok("Package structure is defined") : fail("Package structure/order is missing", "package.structure")
+  },
+  {
+    id: "has-experience",
+    category: "instructional",
+    run: (p) => p.experiences.length > 0 && p.package.experienceRefs.length > 0 ? ok("Package contains at least one experience") : fail("Package has no experiences", "package.experienceRefs")
+  },
+  {
+    id: "structure-covers-experiences",
+    category: "instructional",
+    run: (p) => {
+      const refs = p.package.experienceRefs ?? [];
+      if (refs.length === 0) return skip("No experiences to order yet");
+      if (structureCoversExperiences(p.package.structure, refs)) {
+        return ok("Structure order covers all experiences");
+      }
+      const order = new Set(p.package.structure?.order ?? []);
+      const missing = refs.filter((id) => !order.has(id));
+      return fail(
+        `Structure order is missing experience(s): ${missing.join(", ")}`,
+        "package.structure.order"
+      );
+    }
+  },
+  {
+    id: "experience-has-purpose",
+    category: "instructional",
+    run: (p) => {
+      const bad = p.experiences.find((e) => !e.learningPurpose?.trim());
+      return bad ? fail(`Experience "${bad.id}" has no learning purpose`, `experiences.${bad.id}.learningPurpose`) : ok("Every experience has a learning purpose");
+    }
+  },
+  {
+    id: "experience-has-mechanic",
+    category: "instructional",
+    run: (p) => {
+      const bad = p.experiences.find((e) => !e.mechanicRef?.trim());
+      return bad ? fail(`Experience "${bad.id}" has no mechanic`, `experiences.${bad.id}.mechanicRef`) : ok("Every experience has a mechanic");
+    }
+  },
+  {
+    id: "design-minimal",
+    category: "design",
+    run: (p) => {
+      const level = p.design.level;
+      return level && DESIGN_LEVELS.includes(level) ? ok(`Design direction defined at level "${level}"`) : fail("Design direction is not defined at least minimally", "design.level");
+    }
+  },
+  {
+    id: "design-level-complete",
+    category: "design",
+    run: (p) => checkDesign(p)
+  },
+  {
+    id: "accessibility-considered",
+    category: "accessibility",
+    run: (p) => {
+      const design = p.design;
+      if (design.accessibility) return ok("Accessibility requirements are considered");
+      return warn(
+        "Accessibility requirements are not explicitly captured",
+        "design.accessibility",
+        "Add a design.accessibility section (e.g., a WCAG target)"
+      );
+    }
+  },
+  {
+    id: "completion-rules-present",
+    category: "instructional",
+    run: (p) => p.package.completionRules?.rule ? ok("Package completion rules are defined") : fail("Package-level completion rules are missing", "package.completionRules")
+  },
+  {
+    id: "score-rules-when-assessed",
+    category: "instructional",
+    run: (p) => {
+      const ev = p.package.evaluationRules;
+      if (!ev?.assessed) return skip("Assessment not used at package level");
+      return ev.scoreRules ? ok("Score rules are defined for assessment") : fail("Assessment is used but score rules are missing", "package.evaluationRules.scoreRules");
+    }
+  },
+  {
+    id: "feedback-present",
+    category: "instructional",
+    run: (p) => {
+      const bad = p.experiences.find((e) => !e.feedback?.model);
+      return bad ? fail(`Experience "${bad.id}" has no feedback model`, `experiences.${bad.id}.feedback`) : ok("Feedback exists for learner actions");
+    }
+  },
+  {
+    id: "tracking-defined",
+    category: "tracking",
+    run: (p) => {
+      const t = p.tracking;
+      return t.experienceSignals && t.rollUp ? ok("Tracking signals and roll-up rules are defined") : fail("Tracking requirements are not fully defined", "tracking");
+    }
+  },
+  {
+    id: "export-config-complete",
+    category: "export",
+    run: (p) => {
+      const e = p.export;
+      return Array.isArray(e.targets) && e.targets.length > 0 ? ok("Export configuration defines at least one target") : fail("Export configuration is incomplete (no targets)", "export.targets");
+    }
+  },
+  {
+    id: "tracking-rollup-coherent",
+    category: "tracking",
+    run: (p) => checkTrackingRollup(p)
+  },
+  {
+    id: "export-target-known",
+    category: "export",
+    run: (p) => checkExportTargets(p)
+  },
+  {
+    id: "build-preview-ready",
+    category: "technical",
+    run: () => skip("Run `lxd preview` to verify the package builds and previews")
+  },
+  {
+    id: "not-framework-coupled",
+    category: "portability",
+    run: (p) => checkPortability(p)
+  },
+  {
+    id: "maintainable",
+    category: "maintainability",
+    run: (p) => checkMaintainability(p)
+  },
+  {
+    id: "no-custom-scorm-runtime",
+    category: "technical",
+    run: (p, ctx) => checkScormRuntime(p, ctx)
+  }
+];
+var CHECK_IDS = CHECKS.map((c) => c.id);
+function runValidation(project, ctx) {
+  const checks = CHECKS.map((c) => ({ id: c.id, category: c.category, ...c.run(project, ctx) }));
+  const summary = {
+    pass: checks.filter((c) => c.status === "pass").length,
+    fail: checks.filter((c) => c.status === "fail").length,
+    warn: checks.filter((c) => c.status === "warn").length,
+    skip: checks.filter((c) => c.status === "skip").length,
+    overall: checks.some((c) => c.status === "fail") ? "fail" : "pass"
+  };
+  logger.debug({ overall: summary.overall, fail: summary.fail, warn: summary.warn }, "Validation complete");
+  return { checks, summary };
+}
+function ok(message) {
+  return { status: "pass", message };
+}
+function fail(message, location) {
+  return { status: "fail", message, location };
+}
+function warn(message, location, fix) {
+  return { status: "warn", message, location, fix };
+}
+function skip(message) {
+  return { status: "skip", message };
+}
+
+// src/cli/commands/validate.ts
+function register9(program) {
+  program.command("validate").description("Run all validation checks on the package").option("--json", "output the validation report as JSON").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd);
+    const project = await loadProjectLenient(dir);
+    const report = runValidation(project, { projectDir: dir });
+    if (opts.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      for (const c of report.checks) {
+        const mark = { pass: "\u2713", fail: "\u2717", warn: "!", skip: "\xB7" }[c.status];
+        console.log(`${mark} [${c.category}] ${c.id}: ${c.message}${c.location ? ` (${c.location})` : ""}`);
+      }
+      console.log(
+        `
+${report.summary.overall.toUpperCase()} \u2014 ${report.summary.pass} pass, ${report.summary.fail} fail, ${report.summary.warn} warn, ${report.summary.skip} skip`
+      );
+    }
+    if (report.summary.overall === "fail") process.exitCode = 1;
+  });
+}
+
+// src/core/authoring/tracking-builder.ts
+function buildTrackingConfig(experiences, opts = {}) {
+  const experienceSignals = {};
+  for (const e of experiences) {
+    experienceSignals[e.id] = e.signals && e.signals.length ? e.signals : [...SIGNALS];
+  }
+  const completionRule = opts.completionRule ?? "all-required-complete";
+  const scoreRule = opts.scoreRule ?? "weighted-average";
+  const rollUp = {
+    completion: completionRule === "selected-required-complete" ? { rule: completionRule, requiredExperienceIds: opts.requiredIds ?? [] } : { rule: "all-required-complete" },
+    score: scoreRule === "final-assessment-only" ? { rule: scoreRule, finalAssessmentExperienceId: opts.finalAssessmentExperienceId } : { rule: "weighted-average" },
+    reportedFields: opts.reportedFields ?? ["completion", "score"]
+  };
+  if (opts.threshold !== void 0) {
+    rollUp.success = { scoreThreshold: opts.threshold, requireRequiredExperiencesComplete: true };
+  }
+  return { experienceSignals, rollUp };
+}
+
+// src/cli/commands/tracking.ts
+function register10(program) {
+  program.command("tracking").description("Define experience tracking signals and package roll-up rules").option("--completion-rule <rule>", "all-required-complete | selected-required-complete", "all-required-complete").option("--required <ids...>", "required experience ids (for selected-required-complete)").option("--score-rule <rule>", "weighted-average | final-assessment-only", "weighted-average").option("--final <id>", "final assessment experience id (for final-assessment-only)").option("--threshold <n>", "success score threshold").option("--report <fields...>", "reported fields", ["completion", "score"]).action(
+    async (opts, cmd) => {
+      const dir = cwdOf(cmd);
+      const project = await loadProjectLenient(dir);
+      const tracking = buildTrackingConfig(project.experiences, {
+        completionRule: opts.completionRule,
+        requiredIds: opts.required,
+        scoreRule: opts.scoreRule,
+        finalAssessmentExperienceId: opts.final,
+        reportedFields: opts.report,
+        threshold: opts.threshold !== void 0 ? Number(opts.threshold) : void 0
+      });
+      await writeTracking(dir, tracking);
+      console.log("Tracking configuration updated.");
+    }
+  );
+}
+
+// src/cli/commands/handoff.ts
+import { join as join9 } from "node:path";
+import { access as access4 } from "node:fs/promises";
+import { confirm, isCancel } from "@clack/prompts";
+
+// src/agent/handoff/producer.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// src/agent/handoff/scorm-skills.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var DEFAULT_REF = "github:studiolxd/scorm-skills";
+var DEFAULT_VERSION = "main";
+function renderGuide(ref, version) {
+  return `# Using @studiolxd/scorm (scorm-skills snapshot)
+
+Source: ${ref}
+Version: ${version}
+
+This is a CLI-emitted, version-stamped snapshot of scorm-skills guidance \u2014 not vendored code.
+Implement all SCORM runtime behaviour through **@studiolxd/scorm**. Do NOT hand-roll a SCORM runtime.
+
+## Steps
+
+1. **Add the dependency** to the generated project: \`@studiolxd/scorm\` (use the version pinned in the
+   handoff / package manifest).
+2. **Import and initialize** the runtime once at startup (do not touch \`window.API\` /
+   \`window.API_1484_11\` directly):
+   \`\`\`js
+   import { Scorm } from '@studiolxd/scorm';
+   const scorm = new Scorm();
+   scorm.initialize();
+   \`\`\`
+3. **Local preview**: use the library's mock mode (or the CLI \`preview --mock-lms\`) to verify
+   tracking without a real LMS.
+4. **Report** learner state through the library: completion, success, score, suspend_data,
+   lesson_location, and interactions.
+5. **Commit** progress periodically (the library's commit), and **terminate** safely on exit.
+6. **SCORM 1.2 vs 2004**: let \`@studiolxd/scorm\` handle the cmi differences (1.2
+   \`cmi.core.*\`/\`lesson_status\` vs 2004 \`completion_status\`/\`success_status\`/\`score.scaled\`).
+   Select the edition via configuration \u2014 do not branch on raw API objects yourself.
+
+## Do NOT
+
+- Do NOT implement or assign \`window.API\` / \`window.API_1484_11\`.
+- Do NOT write custom \`LMSInitialize\` / \`LMSCommit\` / \`LMSFinish\` / \`LMSGetValue\` / \`LMSSetValue\`
+  handlers, or custom 2004 \`Initialize\` / \`Terminate\` / \`Commit\` / \`GetValue\` / \`SetValue\`.
+- Do NOT re-implement cmi mapping \u2014 \`@studiolxd/scorm\` owns it.
+`;
+}
+async function writeScormSkillsSnapshot(agentDir, opts = {}) {
+  const dir = join4(agentDir, "scorm-skills");
+  await mkdir2(dir, { recursive: true });
+  const version = opts.version ?? DEFAULT_VERSION;
+  const ref = opts.ref ?? DEFAULT_REF;
+  const snapshot = {
+    source: ref,
+    version,
+    vendored: false,
+    note: "Emitted, version-stamped snapshot of external scorm-skills guidance. Not vendored/forked."
+  };
+  await writeFile2(join4(dir, "SNAPSHOT.json"), JSON.stringify(snapshot, null, 2), "utf8");
+  await writeFile2(join4(dir, "GUIDE.md"), renderGuide(ref, version), "utf8");
+  return { ref: `${ref}@${version}` };
+}
+
+// src/core/project/assets.ts
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+import { parse as parseYaml4, stringify as stringifyYaml2 } from "yaml";
+var MANIFEST_PATH = [".elearning", "manifest.lock"];
+var RECOMMENDED_ASSETS = {
+  scormLibraryVersion: "^1.0.0",
+  scormSkillsSnapshot: { version: "main", ref: "github:studiolxd/scorm-skills" }
+};
+function manifestFile(dir) {
+  return join5(dir, ...MANIFEST_PATH);
+}
+async function readManifest(dir) {
+  try {
+    return parseYaml4(await readFile4(manifestFile(dir), "utf8"));
+  } catch {
+    return { cliVersion: "0.0.0" };
+  }
+}
+async function writeManifest(dir, manifest) {
+  await mkdir3(join5(dir, ".elearning"), { recursive: true });
+  await writeFile3(manifestFile(dir), stringifyYaml2(manifest), "utf8");
+}
+async function updateAssets(dir, update) {
+  const manifest = await readManifest(dir);
+  if (update.scormLibraryVersion) manifest.scormLibraryVersion = update.scormLibraryVersion;
+  if (update.scormSkillsVersion || update.scormSkillsRef) {
+    manifest.scormSkillsSnapshot = {
+      version: update.scormSkillsVersion ?? manifest.scormSkillsSnapshot?.version ?? RECOMMENDED_ASSETS.scormSkillsSnapshot.version,
+      ref: update.scormSkillsRef ?? manifest.scormSkillsSnapshot?.ref ?? RECOMMENDED_ASSETS.scormSkillsSnapshot.ref
+    };
+  }
+  await writeManifest(dir, manifest);
+  logger.debug({ dir }, "Updated external asset versions (explicit)");
+  return manifest;
+}
+
+// src/agent/handoff/producer.ts
+function isScormTargeted2(targets) {
+  return targets.some((t) => t.startsWith("scorm"));
+}
+function renderScormRequirements(input) {
+  const version = input.scormLibraryVersion ?? RECOMMENDED_ASSETS.scormLibraryVersion;
+  return [
+    `## SCORM runtime requirements (MANDATORY)`,
+    `- Do NOT implement a custom SCORM runtime: no \`window.API\`/\`window.API_1484_11\` discovery or`,
+    `  assignment, and no hand-written \`LMS*\` (1.2) or \`Initialize\`/\`Terminate\`/\`Commit\`/\`GetValue\`/`,
+    `  \`SetValue\` (2004) handlers.`,
+    `- Use \`@studiolxd/scorm\` as the runtime integration layer for ALL SCORM interactions (progress,`,
+    `  score, completion, success, suspend_data, lesson_location, interactions, commit, terminate).`,
+    `- Add \`@studiolxd/scorm@${version}\` as a project dependency, then import and use it for the runtime`,
+    `  (see \`.agent/scorm-skills/\` for concrete steps).`
+  ].join("\n");
+}
+var VERSION = "0.1.0";
+function createHandoffProducer() {
+  return {
+    version: VERSION,
+    async produce(input) {
+      const out = input.outputDir;
+      await mkdir4(join6(out, "prompts"), { recursive: true });
+      const spec = renderSpec(input);
+      const specPath = join6(out, "spec.md");
+      await writeFile4(specPath, spec, "utf8");
+      const prompts = [];
+      const shellPath = join6(out, "prompts", "package-shell.md");
+      await writeFile4(shellPath, renderShellPrompt(input), "utf8");
+      prompts.push({ id: "package-shell", path: shellPath });
+      for (const ref of input.package.experienceRefs) {
+        const p = join6(out, "prompts", `${ref}.md`);
+        await writeFile4(p, renderExperiencePrompt(ref, input), "utf8");
+        prompts.push({ id: ref, path: p });
+      }
+      const instructions = renderInstructions(input);
+      await writeFile4(join6(out, "instructions.md"), instructions, "utf8");
+      let scormSkillsSnapshotRef = input.scormSkills?.snapshotRef;
+      if (input.targets.some((t) => t.startsWith("scorm"))) {
+        const snap = await writeScormSkillsSnapshot(out, {
+          version: input.scormSkills?.version,
+          ref: input.scormSkills?.snapshotRef
+        });
+        scormSkillsSnapshotRef = snap.ref;
+      }
+      logger.debug({ outputDir: out, prompts: prompts.length }, "Agent handoff produced");
+      return {
+        spec,
+        prompts,
+        instructions,
+        scormSkillsSnapshotRef,
+        producedBy: VERSION
+      };
+    }
+  };
+}
+function renderSpec(input) {
+  const pkg = input.package;
+  const lines = [`# Package spec: ${pkg.title ?? pkg.id}`, ``, `Learning goal: ${pkg.learningGoal}`];
+  if (pkg.audience?.description) lines.push(`Audience: ${pkg.audience.description}`);
+  if (pkg.context) lines.push(`Context: ${pkg.context}`);
+  if (pkg.tone) lines.push(`Package tone: ${pkg.tone}`);
+  lines.push(`Targets: ${input.targets.join(", ")}`);
+  lines.push(`Experiences: ${pkg.experienceRefs.join(", ")}`);
+  lines.push(``);
+  lines.push(renderDesign(input.design));
+  if (input.experiences?.length) {
+    lines.push(``);
+    lines.push(renderExperiencesSection(input.experiences));
+  }
+  if (isScormTargeted2(input.targets)) {
+    lines.push(``);
+    lines.push(renderScormRequirements(input));
+  }
+  lines.push(``);
+  lines.push(`## Framework implementation contract`);
+  lines.push(input.frameworkContract);
+  return lines.join("\n");
+}
+function renderExperiencesSection(experiences) {
+  const blocks = experiences.map((he) => {
+    const e = he.experience;
+    const l = [`### Experience: ${e.id} \u2014 ${e.title}`];
+    if (e.learningPurpose) l.push(`Learning purpose: ${e.learningPurpose}`);
+    if (e.scenario?.summary) l.push(`Scenario: ${e.scenario.summary}`);
+    if (e.scenario?.context) l.push(`Scenario context: ${e.scenario.context}`);
+    if (he.mechanic) {
+      l.push(`Mechanic: ${he.mechanic.name} (${he.mechanic.id})`);
+      if (he.mechanic.description) l.push(`Mechanic description: ${he.mechanic.description}`);
+      if (he.mechanic.requiredInputs?.length)
+        l.push(`Required inputs: ${he.mechanic.requiredInputs.map((i) => i.key).join(", ")}`);
+      if (he.mechanic.agentGuidance) l.push(`Mechanic guidance: ${he.mechanic.agentGuidance}`);
+    } else {
+      l.push(`Mechanic: ${e.mechanicRef} (not resolved)`);
+    }
+    if (he.pluginEnrichment) l.push(`Mechanic plugin guidance: ${he.pluginEnrichment}`);
+    if (e.feedback?.model) l.push(`Feedback model: ${e.feedback.model}`);
+    const signals = he.trackingSignals ?? e.signals;
+    if (signals?.length) l.push(`Tracking expectations: ${signals.join(", ")}`);
+    return l.join("\n");
+  });
+  return [`## Experiences`, ``, blocks.join("\n\n")].join("\n");
+}
+function renderDesign(design) {
+  const d = design;
+  const lines = [`## Design direction (level: ${d.level ?? "unset"})`];
+  if (d.brief) lines.push(`Brief: ${d.brief}`);
+  if (d.tone) lines.push(`Tone: ${d.tone}`);
+  if (d.output?.length) lines.push(`Output requirements: ${d.output.join(", ")}`);
+  if (d.accessibility?.targets?.length) lines.push(`Accessibility targets: ${d.accessibility.targets.join(", ")}`);
+  if (d.tokens) lines.push(`Design tokens: ${Object.keys(d.tokens).join(", ")} (see design/design-direction.yml)`);
+  if (d.patterns?.ui?.length) lines.push(`UI patterns: ${d.patterns.ui.join(", ")}`);
+  if (d.patterns?.interaction?.length) lines.push(`Interaction patterns: ${d.patterns.interaction.join(", ")}`);
+  if (d.designSystemRefs?.length)
+    lines.push(`Design system references: ${d.designSystemRefs.map((r) => r.ref).join(", ")}`);
+  if (d.constraints?.do?.length) lines.push(`Do: ${d.constraints.do.join("; ")}`);
+  if (d.constraints?.dont?.length) lines.push(`Don't: ${d.constraints.dont.join("; ")}`);
+  if (d.constraints?.implementation?.length)
+    lines.push(`Implementation constraints (MUST): ${d.constraints.implementation.join("; ")}`);
+  return lines.join("\n");
+}
+function renderShellPrompt(input) {
+  return `Implement the package shell for "${input.package.id}" with ${input.package.structure?.navigation ?? "linear"} navigation across experiences: ${input.package.experienceRefs.join(", ")}.`;
+}
+function renderExperiencePrompt(ref, input) {
+  const he = input.experiences?.find((x) => x.experience.id === ref);
+  if (!he) {
+    return `Implement experience "${ref}" in package "${input.package.id}" following the framework implementation contract and the package design direction.`;
+  }
+  const e = he.experience;
+  const l = [`# Prompt: implement experience "${e.id}" \u2014 ${e.title}`, ``, `Package: ${input.package.id}`];
+  if (e.learningPurpose) l.push(`Learning purpose: ${e.learningPurpose}`);
+  if (e.scenario?.summary) l.push(`Scenario: ${e.scenario.summary}`);
+  if (he.mechanic) {
+    l.push(`Mechanic: ${he.mechanic.name} (${he.mechanic.id})`);
+    if (he.mechanic.agentGuidance) l.push(`Mechanic guidance: ${he.mechanic.agentGuidance}`);
+  } else {
+    l.push(`Mechanic: ${e.mechanicRef}`);
+  }
+  if (he.pluginEnrichment) l.push(`Mechanic plugin guidance: ${he.pluginEnrichment}`);
+  if (e.feedback?.model) l.push(`Feedback expectations: ${e.feedback.model} feedback for meaningful learner actions.`);
+  const signals = he.trackingSignals ?? e.signals;
+  if (signals?.length) l.push(`Tracking expectations: emit ${signals.join(", ")}.`);
+  l.push(`Export targets: ${input.targets.join(", ")}.`);
+  if (isScormTargeted2(input.targets)) {
+    l.push(`SCORM: integrate \`@studiolxd/scorm\` for the runtime \u2014 do NOT hand-roll a SCORM runtime (see spec.md \u2192 "SCORM runtime requirements").`);
+  }
+  l.push(`Design constraints: follow the package design direction in spec.md (see "Design direction").`);
+  l.push(`Implement under generated/ per the framework implementation contract.`);
+  return l.join("\n");
+}
+function renderInstructions(input) {
+  const lines = [
+    `# Agent instructions`,
+    ``,
+    `These handoff materials (spec.md and the per-experience prompts under prompts/) are the SOURCE OF TRUTH`,
+    `for the learning design. Implement to them \u2014 do not infer the learning design from code alone.`,
+    ``,
+    `Use your own AI coding agent to implement this package under generated/. Keep the implementation`,
+    `framework-agnostic per the implementation contract. Export targets: ${input.targets.join(", ")}.`
+  ];
+  if (isScormTargeted2(input.targets)) {
+    lines.push(``);
+    lines.push(renderScormRequirements(input));
+  }
+  return lines.join("\n");
+}
+
+// src/adapters/framework/webcomponents/index.ts
+import { mkdir as mkdir5, writeFile as writeFile5, cp, access as access3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+
+// src/preview/server.ts
+import { createServer } from "node:http";
+import { readFile as readFile5, stat } from "node:fs/promises";
+import { join as join7, normalize, extname as extname2 } from "node:path";
+
+// src/preview/mock-lms/index.ts
+function mockLmsBrowserScript() {
+  return `(() => {
+  const data = {};
+  const get = (k) => (k in data ? data[k] : '');
+  const set = (k, v) => { data[k] = String(v); render(); return 'true'; };
+  const ok = () => 'true';
+  // SCORM 1.2 API
+  window.API = {
+    LMSInitialize: ok, LMSFinish: ok, LMSCommit: ok,
+    LMSGetValue: get, LMSSetValue: set,
+    LMSGetLastError: () => '0', LMSGetErrorString: () => '', LMSGetDiagnostic: () => '',
+  };
+  // SCORM 2004 API
+  window.API_1484_11 = {
+    Initialize: ok, Terminate: ok, Commit: ok,
+    GetValue: get, SetValue: set,
+    GetLastError: () => '0', GetErrorString: () => '', GetDiagnostic: () => '',
+  };
+  function render() {
+    let el = document.getElementById('__mock_lms__');
+    if (!el) {
+      el = document.createElement('pre');
+      el.id = '__mock_lms__';
+      el.style.cssText = 'position:fixed;bottom:0;right:0;max-width:40ch;margin:0;padding:8px;background:#111;color:#0f0;font:11px monospace;z-index:99999;opacity:.9';
+      document.body.appendChild(el);
+    }
+    el.textContent = 'MOCK LMS\\n' + JSON.stringify(data, null, 2);
+  }
+  if (document.readyState !== 'loading') render();
+  else document.addEventListener('DOMContentLoaded', render);
+})();`;
+}
+
+// src/preview/server.ts
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg"
+};
+async function startPreviewServer(opts) {
+  const root = normalize(opts.dir);
+  const server = createServer((req, res) => {
+    void (async () => {
+      try {
+        const rel = decodeURIComponent((req.url ?? "/").split("?")[0] ?? "/");
+        if (opts.mockLms && rel === "/mock-lms.js") {
+          res.writeHead(200, { "content-type": MIME[".js"] }).end(mockLmsBrowserScript());
+          return;
+        }
+        const safe = normalize(join7(root, rel === "/" ? "index.html" : `.${rel}`));
+        if (!safe.startsWith(root)) {
+          res.writeHead(403).end("Forbidden");
+          return;
+        }
+        const info = await stat(safe).catch(() => null);
+        const file = info?.isDirectory() ? join7(safe, "index.html") : safe;
+        const isHtml = extname2(file) === ".html";
+        if (opts.mockLms && isHtml) {
+          const html = await readFile5(file, "utf8");
+          const injected = html.includes("</head>") ? html.replace("</head>", '<script src="/mock-lms.js"></script></head>') : `<script src="/mock-lms.js"></script>
+${html}`;
+          res.writeHead(200, { "content-type": MIME[".html"] }).end(injected);
+          return;
+        }
+        const body = await readFile5(file);
+        res.writeHead(200, { "content-type": MIME[extname2(file)] ?? "application/octet-stream" });
+        res.end(body);
+      } catch {
+        res.writeHead(404).end("Not found");
+      }
+    })();
+  });
+  await new Promise((resolve6) => server.listen(opts.port ?? 0, resolve6));
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : opts.port ?? 0;
+  return {
+    url: `http://localhost:${port}`,
+    close: () => new Promise(
+      (resolve6, reject) => server.close((err) => err ? reject(err) : resolve6())
+    )
+  };
+}
+
+// src/adapters/framework/webcomponents/index.ts
+async function exists(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var IMPLEMENTATION_CONTRACT = `Implement each experience as a standards-based Web Component
+(Custom Element + Shadow DOM). The package shell renders experiences per the package structure and
+emits the canonical tracking signals (progress, score, completion, interaction, feedback, suspend).
+Do not depend on any frontend framework. Place your implementation under generated/.`;
+var webComponentsAdapter = {
+  id: "webcomponents",
+  displayName: "Vanilla JS + Web Components",
+  version: "0.1.0",
+  optionsSchema: { type: "object", additionalProperties: true },
+  async scaffold(input) {
+    await mkdir5(input.outputDir, { recursive: true });
+    const files = [];
+    const configPath = join8(input.outputDir, "elearning.scaffold.json");
+    await writeFile5(
+      configPath,
+      JSON.stringify({ adapter: this.id, packageId: input.package.id }, null, 2),
+      "utf8"
+    );
+    files.push(configPath);
+    const contractPath = join8(input.outputDir, "AGENT_IMPLEMENTATION.md");
+    await writeFile5(contractPath, IMPLEMENTATION_CONTRACT, "utf8");
+    files.push(contractPath);
+    const generated = join8(input.outputDir, "generated");
+    await mkdir5(generated, { recursive: true });
+    const seed = join8(generated, "index.html");
+    const preserved = [];
+    const overwritten = [];
+    const seedExists = await exists(seed);
+    if (seedExists && !input.force) {
+      preserved.push(seed);
+      logger.debug({ file: seed }, "Preserved existing generated/ file (use force to overwrite)");
+    } else {
+      await writeFile5(seed, "<!doctype html><title>elearning package</title>", "utf8");
+      files.push(seed);
+      if (seedExists) {
+        overwritten.push(seed);
+        logger.debug({ file: seed }, "Overwrote generated/ file (force)");
+      }
+    }
+    logger.debug(
+      { outputDir: input.outputDir, written: files.length, preserved: preserved.length },
+      "webcomponents scaffold complete"
+    );
+    return { files, implementationContract: IMPLEMENTATION_CONTRACT, preserved, overwritten };
+  },
+  async build(input) {
+    await mkdir5(input.outputDir, { recursive: true });
+    const source = input.generatedDir;
+    if (source && await exists(source)) {
+      await cp(source, input.outputDir, { recursive: true });
+    }
+    logger.debug({ outputDir: input.outputDir, from: source }, "webcomponents build complete");
+    return { outputDir: input.outputDir };
+  },
+  async preview(input) {
+    const dir = input?.builtDir ?? process.cwd();
+    return startPreviewServer({ dir, port: input?.port ?? 0 });
+  }
+};
+
+// src/core/authoring/handoff-service.ts
+async function buildHandoffExperiences(project) {
+  const registry = await createMechanicRegistry();
+  const trackingSignalsById = project.tracking.experienceSignals ?? {};
+  return project.experiences.map((e) => {
+    const view = {
+      experience: e,
+      trackingSignals: trackingSignalsById[e.id] ?? e.signals
+    };
+    if (registry.has(e.mechanicRef)) {
+      const resolved = registry.getResolved(e.mechanicRef);
+      view.mechanic = {
+        id: resolved.manifest.id,
+        name: resolved.manifest.name,
+        description: resolved.manifest.description,
+        requiredInputs: resolved.manifest.requiredInputs,
+        agentGuidance: resolved.manifest.agentGuidance
+      };
+      view.pluginEnrichment = resolved.plugin?.enrichHandoff?.(e);
+    }
+    return view;
+  });
+}
+async function produceHandoff(project, opts) {
+  const experiences = await buildHandoffExperiences(project);
+  return createHandoffProducer().produce({
+    package: project.package,
+    design: project.design,
+    mechanics: [],
+    experiences,
+    tracking: project.tracking,
+    scormLibraryVersion: project.manifest?.scormLibraryVersion,
+    frameworkContract: webComponentsAdapter.displayName,
+    targets: opts.targets,
+    outputDir: opts.outputDir
+  });
+}
+
+// src/core/validation/handoff-agnostic.ts
+var PROVIDER_TOKENS = [
+  "claude",
+  "anthropic",
+  "cursor",
+  "codex",
+  "openai",
+  "gpt-",
+  "gemini",
+  "copilot"
+];
+var CREDENTIAL_PATTERNS = [
+  // Word boundary avoids false positives like "ri[sk-detection]" (mechanic ids).
+  /\bsk-[a-z0-9]{8,}/i,
+  /api[_-]?key\s*[:=]/i,
+  /bearer\s+[a-z0-9._-]{8,}/i,
+  /authorization\s*:/i
+];
+function checkHandoffAgnostic(text) {
+  const lower = text.toLowerCase();
+  const issues = [];
+  for (const token of PROVIDER_TOKENS) {
+    if (lower.includes(token)) issues.push({ kind: "provider", token });
+  }
+  for (const re of CREDENTIAL_PATTERNS) {
+    const m = text.match(re);
+    if (m) issues.push({ kind: "credential", token: m[0] });
+  }
+  return { ok: issues.length === 0, issues };
+}
+
+// src/cli/commands/handoff.ts
+async function exists2(path) {
+  try {
+    await access4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function register11(program) {
+  program.command("handoff").description("Generate agent-ready specs/prompts and scaffold the project for an agent").option("-t, --target <ids...>", "export targets", ["web"]).option("-f, --force", "overwrite existing files under generated/ when scaffolding").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd);
+    const project = await loadProjectLenient(dir);
+    const experiences = await buildHandoffExperiences(project);
+    const mechRegistry = await createMechanicRegistry();
+    for (const e of project.experiences) {
+      if (!mechRegistry.has(e.mechanicRef)) continue;
+      for (const issue of mechRegistry.getResolved(e.mechanicRef).plugin?.validate?.(e) ?? []) {
+        if (!issue.ok) console.warn(`  ${e.id} (${e.mechanicRef}): ${issue.message}`);
+      }
+    }
+    const producer = createHandoffProducer();
+    const materials = await producer.produce({
+      package: project.package,
+      design: project.design,
+      mechanics: [],
+      experiences,
+      tracking: project.tracking,
+      scormLibraryVersion: project.manifest?.scormLibraryVersion,
+      frameworkContract: webComponentsAdapter.displayName,
+      targets: opts.target,
+      outputDir: join9(dir, ".agent")
+    });
+    console.log(`Handoff materials written to .agent/ (${materials.prompts.length} prompts).`);
+    const agnostic = checkHandoffAgnostic(`${materials.spec}
+${materials.instructions}`);
+    if (!agnostic.ok) {
+      for (const issue of agnostic.issues) {
+        console.warn(`  warning: handoff contains ${issue.kind} reference "${issue.token}" \u2014 keep it agent-agnostic`);
+      }
+    }
+    let force = Boolean(opts.force);
+    const seed = join9(dir, "generated", "index.html");
+    if (!force && await exists2(seed)) {
+      if (process.stdin.isTTY) {
+        const answer = await confirm({
+          message: "generated/ already contains files. Overwrite matching scaffold files?",
+          initialValue: false
+        });
+        force = !isCancel(answer) && answer === true;
+      } else {
+        console.warn(
+          "Warning: generated/ already contains files \u2014 preserving them. Re-run with --force to overwrite."
+        );
+      }
+    }
+    const scaffold = await webComponentsAdapter.scaffold({
+      package: project.package,
+      design: project.design,
+      mechanics: [],
+      outputDir: dir,
+      options: {},
+      force
+    });
+    if (scaffold.preserved?.length) {
+      console.warn(
+        `Preserved ${scaffold.preserved.length} existing file(s) under generated/ (use --force to overwrite).`
+      );
+    }
+    if (scaffold.overwritten?.length) {
+      console.warn(`Overwrote ${scaffold.overwritten.length} file(s) under generated/.`);
+    }
+    console.log("Project scaffolded for the agent (generated/).");
+  });
+}
+
+// src/cli/commands/preview.ts
+import { join as join10 } from "node:path";
+function register12(program) {
+  program.command("preview").description("Build the package and serve it locally").option("--mock-lms", "serve in mock LMS/SCORM mode (US2)").option("-p, --port <n>", "port", "0").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd);
+    const project = await loadProjectLenient(dir);
+    const built = await webComponentsAdapter.build({
+      package: project.package,
+      outputDir: join10(dir, "build"),
+      generatedDir: join10(dir, "generated")
+    });
+    const handle = await startPreviewServer({
+      dir: built.outputDir,
+      port: Number(opts.port),
+      mockLms: Boolean(opts.mockLms)
+    });
+    console.log(
+      `Preview serving at ${handle.url}${opts.mockLms ? " (mock LMS enabled)" : ""} (press Ctrl+C to stop)`
+    );
+  });
+}
+
+// src/cli/commands/export.ts
+import { join as join13 } from "node:path";
+
+// src/core/authoring/export-builder.ts
+function buildExportConfig(targetIds) {
+  return { targets: targetIds.map((id) => ({ adapterId: id })) };
+}
+
+// src/adapters/export/registry.ts
+function createExportRegistry() {
+  const adapters = /* @__PURE__ */ new Map();
+  return {
+    register(adapter) {
+      adapters.set(adapter.id, adapter);
+    },
+    has(id) {
+      return adapters.has(id);
+    },
+    get(id) {
+      const adapter = adapters.get(id);
+      if (!adapter) {
+        throw new Error(
+          `No export adapter for target "${id}". Available: ${[...adapters.keys()].join(", ") || "(none)"}`
+        );
+      }
+      return adapter;
+    },
+    list() {
+      return [...adapters.values()];
+    }
+  };
+}
+
+// src/adapters/export/web/index.ts
+import { mkdir as mkdir6, cp as cp2, access as access5 } from "node:fs/promises";
+var webExportAdapter = {
+  id: "web",
+  displayName: "Web / static package",
+  version: "0.1.0",
+  optionsSchema: { type: "object", additionalProperties: true },
+  async validate(input) {
+    const built = await access5(input.builtDir).then(
+      () => true,
+      () => false
+    );
+    return [
+      {
+        id: "web-built-dir-present",
+        category: "export",
+        status: built ? "pass" : "fail",
+        message: built ? "Built directory is present" : `Built directory not found: ${input.builtDir}`,
+        location: input.builtDir
+      }
+    ];
+  },
+  async export(input) {
+    await mkdir6(input.outputDir, { recursive: true });
+    await cp2(input.builtDir, input.outputDir, { recursive: true });
+    logger.debug({ outputDir: input.outputDir }, "web export complete");
+    return { artifactPath: input.outputDir, target: "web", warnings: [] };
+  }
+};
+
+// src/adapters/export/scorm12/index.ts
+import { mkdir as mkdir7, cp as cp3, writeFile as writeFile6, access as access6 } from "node:fs/promises";
+import { join as join11 } from "node:path";
+
+// src/adapters/export/scorm-common.ts
+import archiver from "archiver";
+import { createWriteStream } from "node:fs";
+function buildImsManifest12(pkg) {
+  const title = escapeXml(pkg.title ?? pkg.id);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<manifest identifier="${escapeXml(pkg.id)}" version="1.0"
+  xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+  xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_rootv1p2"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>1.2</schemaversion>
+  </metadata>
+  <organizations default="ORG-${escapeXml(pkg.id)}">
+    <organization identifier="ORG-${escapeXml(pkg.id)}">
+      <title>${title}</title>
+      <item identifier="ITEM-1" identifierref="RES-1">
+        <title>${title}</title>
+      </item>
+    </organization>
+  </organizations>
+  <resources>
+    <resource identifier="RES-1" type="webcontent" adlcp:scormtype="sco" href="index.html">
+      <file href="index.html"/>
+    </resource>
+  </resources>
+</manifest>
+`;
+}
+function buildImsManifest2004(pkg) {
+  const title = escapeXml(pkg.title ?? pkg.id);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!-- SCORM 2004 4th Edition (CAM 1.3) -->
+<manifest identifier="${escapeXml(pkg.id)}" version="1.0"
+  xmlns="http://www.imsglobal.org/xsd/imscp_v1p1"
+  xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_v1p3"
+  xmlns:adlseq="http://www.adlnet.org/xsd/adlseq_v1p3"
+  xmlns:adlnav="http://www.adlnet.org/xsd/adlnav_v1p3"
+  xmlns:imsss="http://www.imsglobal.org/xsd/imsss"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <metadata>
+    <schema>ADL SCORM</schema>
+    <schemaversion>2004 4th Edition</schemaversion>
+  </metadata>
+  <organizations default="ORG-${escapeXml(pkg.id)}">
+    <organization identifier="ORG-${escapeXml(pkg.id)}">
+      <title>${title}</title>
+      <item identifier="ITEM-1" identifierref="RES-1">
+        <title>${title}</title>
+        <imsss:sequencing/>
+      </item>
+    </organization>
+  </organizations>
+  <resources>
+    <resource identifier="RES-1" type="webcontent" adlcp:scormType="sco" href="index.html">
+      <file href="index.html"/>
+    </resource>
+  </resources>
+</manifest>
+`;
+}
+function zipDir(srcDir, destZip) {
+  return new Promise((resolve6, reject) => {
+    const output = createWriteStream(destZip);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    output.on("close", () => resolve6());
+    archive.on("error", reject);
+    archive.pipe(output);
+    archive.directory(srcDir, false);
+    void archive.finalize();
+  });
+}
+function escapeXml(s) {
+  return s.replace(
+    /[<>&"']/g,
+    (c) => c === "<" ? "&lt;" : c === ">" ? "&gt;" : c === "&" ? "&amp;" : c === '"' ? "&quot;" : "&apos;"
+  );
+}
+
+// src/adapters/export/scorm12/index.ts
+var scorm12Adapter = {
+  id: "scorm-1.2",
+  displayName: "SCORM 1.2",
+  version: "0.1.0",
+  optionsSchema: { type: "object", additionalProperties: true },
+  async validate(input) {
+    const built = await access6(input.builtDir).then(
+      () => true,
+      () => false
+    );
+    const results = [
+      {
+        id: "scorm12-built-dir-present",
+        category: "export",
+        status: built ? "pass" : "fail",
+        message: built ? "Built directory is present" : `Built directory not found: ${input.builtDir}`,
+        location: input.builtDir
+      }
+    ];
+    if (!input.assets.scormLibraryVersion) {
+      results.push({
+        id: "scorm12-runtime-version",
+        category: "export",
+        status: "warn",
+        message: "@studiolxd/scorm version is not pinned in manifest.lock",
+        fix: "Run `lxd assets update --scorm-version <range>`"
+      });
+    }
+    return results;
+  },
+  async export(input) {
+    await mkdir7(input.outputDir, { recursive: true });
+    await cp3(input.builtDir, input.outputDir, { recursive: true });
+    await writeFile6(join11(input.outputDir, "imsmanifest.xml"), buildImsManifest12(input.package), "utf8");
+    await writeFile6(
+      join11(input.outputDir, "scorm-runtime.json"),
+      JSON.stringify(
+        { library: "@studiolxd/scorm", version: input.assets.scormLibraryVersion ?? "unspecified", edition: "SCORM 1.2" },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    const zip = `${input.outputDir}.zip`;
+    await zipDir(input.outputDir, zip);
+    logger.debug({ zip }, "SCORM 1.2 export complete");
+    const warnings = input.assets.scormLibraryVersion ? [] : ["@studiolxd/scorm version not pinned"];
+    return { artifactPath: zip, target: "scorm-1.2", warnings };
+  }
+};
+
+// src/adapters/export/scorm2004/index.ts
+import { mkdir as mkdir8, cp as cp4, writeFile as writeFile7, access as access7 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+var scorm2004Adapter = {
+  id: "scorm-2004",
+  displayName: "SCORM 2004 (4th Edition)",
+  version: "0.1.0",
+  optionsSchema: { type: "object", additionalProperties: true },
+  async validate(input) {
+    const built = await access7(input.builtDir).then(
+      () => true,
+      () => false
+    );
+    const results = [
+      {
+        id: "scorm2004-built-dir-present",
+        category: "export",
+        status: built ? "pass" : "fail",
+        message: built ? "Built directory is present" : `Built directory not found: ${input.builtDir}`,
+        location: input.builtDir
+      }
+    ];
+    if (!input.assets.scormLibraryVersion) {
+      results.push({
+        id: "scorm2004-runtime-version",
+        category: "export",
+        status: "warn",
+        message: "@studiolxd/scorm version is not pinned in manifest.lock",
+        fix: "Run `lxd assets update --scorm-version <range>`"
+      });
+    }
+    return results;
+  },
+  async export(input) {
+    await mkdir8(input.outputDir, { recursive: true });
+    await cp4(input.builtDir, input.outputDir, { recursive: true });
+    await writeFile7(join12(input.outputDir, "imsmanifest.xml"), buildImsManifest2004(input.package), "utf8");
+    await writeFile7(
+      join12(input.outputDir, "scorm-runtime.json"),
+      JSON.stringify(
+        {
+          library: "@studiolxd/scorm",
+          version: input.assets.scormLibraryVersion ?? "unspecified",
+          edition: "SCORM 2004 4th Edition"
+        },
+        null,
+        2
+      ),
+      "utf8"
+    );
+    const zip = `${input.outputDir}.zip`;
+    await zipDir(input.outputDir, zip);
+    logger.debug({ zip }, "SCORM 2004 export complete");
+    const warnings = input.assets.scormLibraryVersion ? [] : ["@studiolxd/scorm version not pinned"];
+    return { artifactPath: zip, target: "scorm-2004", warnings };
+  }
+};
+
+// src/cli/commands/export.ts
+function register13(program) {
+  program.command("export").description("Export the package to one or more targets").option("-t, --target <ids...>", "export target ids (web|scorm-1.2|scorm-2004)").action(async (opts, cmd) => {
+    const dir = cwdOf(cmd);
+    const project = await loadProjectLenient(dir);
+    const registry = createExportRegistry();
+    registry.register(webExportAdapter);
+    registry.register(scorm12Adapter);
+    registry.register(scorm2004Adapter);
+    const manifest = await readManifest(dir);
+    const targets = opts.target ?? project.export.targets?.map((t) => t.adapterId) ?? [];
+    if (targets.length === 0) {
+      console.error("No export targets specified. Use --target <id> or define export.config.yml.");
+      process.exitCode = 1;
+      return;
+    }
+    const knownForConfig = targets.filter((id) => registry.has(id));
+    if (knownForConfig.length > 0) {
+      await writeExport(dir, buildExportConfig(knownForConfig));
+    }
+    const built = await webComponentsAdapter.build({
+      package: project.package,
+      outputDir: join13(dir, "build"),
+      generatedDir: join13(dir, "generated")
+    });
+    for (const id of targets) {
+      if (!registry.has(id)) {
+        console.error(`No export adapter for target "${id}".`);
+        process.exitCode = 1;
+        continue;
+      }
+      const adapter = registry.get(id);
+      const result = await adapter.export({
+        builtDir: built.outputDir,
+        package: project.package,
+        tracking: project.tracking,
+        options: {},
+        outputDir: join13(dir, "dist", id),
+        assets: {
+          scormLibraryVersion: manifest.scormLibraryVersion,
+          scormSkillsSnapshotRef: manifest.scormSkillsSnapshot?.ref
+        }
+      });
+      for (const w of result.warnings) console.warn(`  warning: ${w}`);
+      console.log(`Exported ${id} -> ${result.artifactPath}`);
+    }
+  });
+}
+
+// src/cli/commands/assets.ts
+function register14(program) {
+  const assets = program.command("assets").description("Manage external versioned assets (@studiolxd/scorm, scorm-skills)");
+  assets.command("show").description("Show pinned external asset versions").action(async (_opts, cmd) => {
+    const manifest = await readManifest(cwdOf(cmd.parent));
+    console.log(JSON.stringify(manifest, null, 2));
+  });
+  assets.command("update").description("Explicitly update external asset versions (never silent)").option("--scorm-version <range>", "@studiolxd/scorm version range").option("--skills-version <version>", "scorm-skills snapshot version").option("--skills-ref <ref>", "scorm-skills source ref").action(
+    async (opts, cmd) => {
+      const dir = cwdOf(cmd.parent);
+      await updateAssets(dir, {
+        scormLibraryVersion: opts.scormVersion,
+        scormSkillsVersion: opts.skillsVersion,
+        scormSkillsRef: opts.skillsRef
+      });
+      console.log("External asset versions updated in manifest.lock.");
+    }
+  );
+}
+
+// src/cli/commands/create.ts
+import { join as join14, resolve as resolve5 } from "node:path";
+import { rm } from "node:fs/promises";
+
+// src/cli/prompt.ts
+import {
+  text as clackText,
+  select as clackSelect,
+  multiselect as clackMultiselect,
+  confirm as clackConfirm,
+  isCancel as clackIsCancel
+} from "@clack/prompts";
+var CANCEL = Symbol("CANCEL");
+function isCancel2(v) {
+  return v === CANCEL;
+}
+var ClackPrompter = class {
+  async text(opts) {
+    const r = await clackText(opts);
+    return clackIsCancel(r) ? CANCEL : r;
+  }
+  async select(opts) {
+    const r = await clackSelect({ message: opts.message, options: opts.options, initialValue: opts.initialValue });
+    return clackIsCancel(r) ? CANCEL : r;
+  }
+  async multiselect(opts) {
+    const r = await clackMultiselect({ message: opts.message, options: opts.options, required: opts.required ?? false });
+    return clackIsCancel(r) ? CANCEL : r;
+  }
+  async confirm(opts) {
+    const r = await clackConfirm({ message: opts.message, initialValue: opts.initialValue });
+    return clackIsCancel(r) ? CANCEL : r;
+  }
+};
+
+// src/core/authoring/project-builder.ts
+function assembleProject(answers, design) {
+  const experiences = answers.experiences.map(buildExperience);
+  const order = experiences.map((e) => e.id);
+  const pkg = {
+    id: answers.id,
+    schemaVersion: "1",
+    learningGoal: answers.learningGoal,
+    audience: { description: answers.audience },
+    duration: { expectedMinutes: answers.durationMinutes },
+    structure: { navigation: "linear", order },
+    experienceRefs: order,
+    designRef: "design",
+    completionRules: { rule: answers.evaluationRule ?? "all-required" },
+    trackingRef: "tracking",
+    exportRef: "export"
+  };
+  if (answers.tone) pkg.tone = answers.tone;
+  const tracking = buildTrackingConfig(experiences, { reportedFields: answers.trackingReports });
+  const exportConfig = buildExportConfig(answers.exportTargets);
+  const manifest = { cliVersion: "0.0.0" };
+  if (answers.exportTargets.some((t) => t.startsWith("scorm"))) {
+    manifest.scormLibraryVersion = RECOMMENDED_ASSETS.scormLibraryVersion;
+    manifest.scormSkillsSnapshot = { ...RECOMMENDED_ASSETS.scormSkillsSnapshot };
+  }
+  return { package: pkg, design, experiences, tracking, export: exportConfig, manifest };
+}
+
+// src/core/authoring/design-loader.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+import { parse as parseYaml5 } from "yaml";
+function buildDesignBrief(brief) {
+  return { level: "brief", brief };
+}
+async function loadDesignFromFile(path, baseDir = ".") {
+  const design = parseYaml5(await readFile6(resolve4(baseDir, path), "utf8"));
+  const result = createValidator().validate("design-direction", design);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid design direction in ${path}: ${result.errors.map((e) => `${e.path} ${e.message}`).join("; ")}`
+    );
+  }
+  return design;
+}
+
+// src/cli/commands/create.ts
+var WizardCancelled = class extends Error {
+};
+async function need(p) {
+  const v = await p;
+  if (isCancel2(v)) throw new WizardCancelled();
+  return v;
+}
+async function runWizard(prompter, opts) {
+  const result = {
+    cancelled: false,
+    committed: false,
+    dir: resolve5(opts.cwd, opts.dir ?? "."),
+    handoffGenerated: false
+  };
+  let answers;
+  try {
+    const targetDir = opts.dir ? resolve5(opts.cwd, opts.dir) : resolve5(opts.cwd, await need(prompter.text({ message: "Package location", initialValue: "." })));
+    result.dir = targetDir;
+    let replacing = false;
+    if (await packageExists(targetDir)) {
+      const replace = await need(
+        prompter.confirm({ message: `A package already exists at ${targetDir}. Replace it?`, initialValue: false })
+      );
+      if (!replace) {
+        console.log("Aborted \u2014 existing package left unchanged.");
+        result.cancelled = true;
+        return result;
+      }
+      replacing = true;
+    }
+    const id = await need(
+      prompter.text({ message: "Package id", validate: (v) => isSlug(v) ? void 0 : "Use a slug (a-z, 0-9, -)" })
+    );
+    const learningGoal = await need(prompter.text({ message: "Learning goal" }));
+    const audience = await need(prompter.text({ message: "Audience" }));
+    const durationStr = await need(
+      prompter.text({
+        message: "Expected duration (minutes)",
+        validate: (v) => Number.isFinite(Number(v)) && Number(v) > 0 ? void 0 : "Enter a positive number"
+      })
+    );
+    const tone = await need(prompter.text({ message: "Package tone", initialValue: "" }));
+    const registry = await createMechanicRegistry();
+    const mechOptions = registry.list().map((m) => ({ value: m.id, label: m.name }));
+    const experiences = [];
+    while (await need(
+      prompter.confirm({
+        message: experiences.length ? "Add another experience?" : "Add an experience?",
+        initialValue: true
+      })
+    )) {
+      const eid = await need(
+        prompter.text({ message: "Experience id", validate: (v) => isSlug(v) ? void 0 : "Use a slug" })
+      );
+      const title = await need(prompter.text({ message: "Title", initialValue: eid }));
+      const learningPurpose = await need(prompter.text({ message: "Learning purpose" }));
+      const scenario = await need(prompter.text({ message: "Scenario" }));
+      const mechanicRef = await need(prompter.select({ message: "Mechanic", options: mechOptions }));
+      experiences.push({ id: eid, title, learningPurpose, scenario, mechanicRef });
+    }
+    let design;
+    const useFile = await need(prompter.confirm({ message: "Use an existing design file (advanced)?", initialValue: false }));
+    if (useFile) {
+      const path = await need(prompter.text({ message: "Design file path" }));
+      design = await loadDesignFromFile(path, targetDir);
+    } else {
+      const brief = await need(prompter.text({ message: "Design brief", initialValue: "" }));
+      design = buildDesignBrief(brief);
+    }
+    const evaluationRule = await need(
+      prompter.select({
+        message: "Completion rule",
+        options: [
+          { value: "all-required", label: "All required experiences complete" },
+          { value: "selected-required", label: "Selected required experiences complete" }
+        ],
+        initialValue: "all-required"
+      })
+    );
+    const trackingReports = await need(
+      prompter.multiselect({ message: "Tracking reports", options: [...REPORTED_FIELDS].map((f) => ({ value: f, label: f })) })
+    );
+    const exportTargets = await need(
+      prompter.multiselect({
+        message: "Export targets",
+        options: [...EXPORT_ADAPTERS_V1].map((t) => ({ value: t, label: t })),
+        required: true
+      })
+    );
+    answers = {
+      id,
+      learningGoal,
+      audience,
+      durationMinutes: Number(durationStr),
+      tone: tone || void 0,
+      experiences,
+      evaluationRule,
+      trackingReports,
+      exportTargets
+    };
+    const commit = await need(
+      prompter.confirm({ message: `Create package "${id}" with ${experiences.length} experience(s)?`, initialValue: true })
+    );
+    if (!commit) {
+      console.log("Cancelled \u2014 no files were written.");
+      result.cancelled = true;
+      return result;
+    }
+    if (replacing) {
+      await rm(join14(targetDir, "experiences"), { recursive: true, force: true });
+    }
+    await saveProject(targetDir, assembleProject(answers, design));
+    result.committed = true;
+  } catch (e) {
+    if (e instanceof WizardCancelled) {
+      console.log("Cancelled \u2014 no files were written.");
+      result.cancelled = true;
+      return result;
+    }
+    throw e;
+  }
+  try {
+    if (await need(prompter.confirm({ message: "Run validation now?", initialValue: true }))) {
+      const report = runValidation(await loadProjectLenient(result.dir), { projectDir: result.dir });
+      result.validation = report;
+      console.log(
+        `Validation: ${report.summary.overall.toUpperCase()} \u2014 ${report.summary.pass} pass, ${report.summary.fail} fail, ${report.summary.warn} warn`
+      );
+    }
+    if (await need(prompter.confirm({ message: "Generate agent handoff now?", initialValue: false }))) {
+      await produceHandoff(await loadProjectLenient(result.dir), {
+        targets: answers.exportTargets,
+        outputDir: join14(result.dir, ".agent")
+      });
+      result.handoffGenerated = true;
+      console.log("Handoff materials written to .agent/.");
+    }
+  } catch (e) {
+    if (e instanceof WizardCancelled) {
+      console.log(`Stopped after commit. The package was already written at ${result.dir}.`);
+      return result;
+    }
+    throw e;
+  }
+  printSummary(answers);
+  return result;
+}
+function printSummary(answers) {
+  console.log("\nCreated package:");
+  console.log(`  id: ${answers.id}`);
+  console.log(`  experiences: ${answers.experiences.length}`);
+  console.log(`  export targets: ${answers.exportTargets.join(", ")}`);
+  console.log("\nNext commands:");
+  console.log("  lxd preview --mock-lms");
+  console.log("  lxd validate");
+  console.log("  lxd handoff");
+  console.log(`  lxd export --target ${answers.exportTargets.join(" --target ")}`);
+}
+function register15(program) {
+  program.command("create [dir]").alias("wizard").description("Guided, interactive creation of a new elearning package").action(async (dir, _opts, cmd) => {
+    await runWizard(new ClackPrompter(), { cwd: cwdOf(cmd), dir });
+  });
+}
+
+// src/cli/index.ts
+var VERSION2 = package_default.version;
+function registerCommands(program) {
+  register(program);
+  register2(program);
+  register3(program);
+  register4(program);
+  register5(program);
+  register6(program);
+  register7(program);
+  register8(program);
+  register9(program);
+  register10(program);
+  register11(program);
+  register12(program);
+  register13(program);
+  register14(program);
+  register15(program);
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("lxd").description("CLI-first authoring tool for AI-native elearning packages").version(VERSION2).option("--log-format <fmt>", "log output format: pretty | json", "pretty").option("--cwd <dir>", "project root directory");
+  registerCommands(program);
+  return program;
+}
+function isInvokedDirectly() {
+  if (process.argv[1] === void 0) return false;
+  const self = fileURLToPath2(import.meta.url);
+  try {
+    return realpathSync(self) === realpathSync(process.argv[1]);
+  } catch {
+    return self === process.argv[1];
+  }
+}
+if (isInvokedDirectly()) {
+  buildProgram().parse(process.argv);
+}
+export {
+  VERSION2 as VERSION,
+  buildProgram,
+  registerCommands
+};