@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.6

package/bin/chunks/chunk-5OOPJNGN.js

@@ -0,0 +1,511 @@
+// src/agent/jev/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_JEV_MODEL = "jev-1.13.0";
+var DEFAULT_ROUTING_CONFIDENCE_THRESHOLD = 0.8;
+var DEFAULT_GROUNDING_CONFIDENCE_THRESHOLD = 0.85;
+var DEFAULT_JEV_CONFIG = {
+  mode: "off",
+  model: DEFAULT_JEV_MODEL,
+  timeoutMs: 3e4,
+  taskDeadlineMs: 12e4,
+  maxConcurrency: 4,
+  maxRetries: 2,
+  confidenceThresholds: {
+    routing: DEFAULT_ROUTING_CONFIDENCE_THRESHOLD,
+    grounding: DEFAULT_GROUNDING_CONFIDENCE_THRESHOLD
+  },
+  compactPackets: false,
+  workOwnership: "agent",
+  pilotBudget: { maxTransportAttempts: 100, maxInputTokens: 2e5 }
+};
+var DEFAULT_JEV_CAPABILITIES = {
+  mediaClassification: "off",
+  mediaSelection: "off",
+  mediaSetReview: "off",
+  mediaProvenance: "off",
+  // Existing
+  grounding: "off",
+  sourceSelection: "off",
+  retrievalRanking: "off",
+  consistency: "off",
+  repairAssistance: "off",
+  preferenceScoring: "off",
+  // Workstream 5
+  claimStrengthening: "off",
+  ctaFidelity: "off",
+  crossStageContinuity: "off",
+  coverageCheck: "off",
+  // Workstream 7
+  creativeScoring: "off",
+  componentSelection: "off",
+  compositionCheck: "off",
+  lessonRanking: "off",
+  visitorQuestionCheck: "off",
+  factContradictionCheck: "off",
+  ctaFitCheck: "off",
+  repetitionExplanationCheck: "off",
+  directionContinuityCheck: "off"
+};
+var DESIGN_ASSIST_CAPABILITIES = ["creativeScoring", "componentSelection", "compositionCheck", "mediaClassification", "mediaSelection", "mediaSetReview", "mediaProvenance"];
+var CREATIVE_EFFICIENCY_CAPABILITIES = ["retrievalRanking", "repairAssistance"];
+var DEFAULT_PILOT_BUDGET = { maxTransportAttempts: 100, maxInputTokens: 2e5 };
+function resolveApiKey(searchDirs = []) {
+  if (process.env.TYPESAFE_API_KEY?.trim()) {
+    return process.env.TYPESAFE_API_KEY.trim();
+  }
+  const dirsToInspect = [
+    process.cwd(),
+    ...searchDirs,
+    join(process.cwd(), ".."),
+    join(process.cwd(), "../vitris-v3")
+  ];
+  for (const dir of dirsToInspect) {
+    const devVarsPath = join(dir, ".dev.vars");
+    if (existsSync(devVarsPath)) {
+      try {
+        const content = readFileSync(devVarsPath, "utf8");
+        for (const line of content.split(/\r?\n/)) {
+          const match = line.match(/^TYPESAFE_API_KEY\s*=\s*([^\s#]+)/);
+          if (match && match[1]?.trim()) {
+            return match[1].trim();
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function loadJevConfig(root, argv = [], env = process.env) {
+  let fileConfig = {};
+  const configPath = join(root, "agent/jev.json");
+  if (existsSync(configPath)) {
+    try {
+      fileConfig = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+      fileConfig = {};
+    }
+  }
+  return mergeJevConfig(fileConfig, argv, env, root);
+}
+function mergeJevConfig(fileConfig, argv = [], env = process.env, root = "") {
+  const capabilities = {
+    ...DEFAULT_JEV_CAPABILITIES,
+    ...fileConfig.capabilities || {}
+  };
+  let mode = DEFAULT_JEV_CONFIG.mode;
+  if (fileConfig.mode && ["off", "shadow", "assist"].includes(fileConfig.mode)) {
+    mode = fileConfig.mode;
+  }
+  const envMode = env.VITRIS_JEV_MODE?.toLowerCase();
+  if (envMode && ["off", "shadow", "assist"].includes(envMode)) {
+    mode = envMode;
+  }
+  const modeIdx = argv.indexOf("--jev-mode");
+  if (modeIdx >= 0 && argv[modeIdx + 1] && ["off", "shadow", "assist"].includes(argv[modeIdx + 1])) {
+    mode = argv[modeIdx + 1];
+  }
+  if (argv.includes("--no-jev")) {
+    mode = "off";
+  }
+  const explicitCapabilityKeys = new Set(Object.keys(fileConfig.capabilities || {}));
+  const presetRequested = argv.includes("--design-assist") || env.VITRIS_DESIGN_ASSIST === "1" || env.VITRIS_DESIGN_ASSIST === "true";
+  const explicitOff = argv.includes("--no-jev") || env.VITRIS_JEV_MODE?.toLowerCase() === "off" || modeIdx >= 0 && argv[modeIdx + 1] === "off";
+  if (presetRequested && !explicitOff) {
+    if (mode === "off") mode = "assist";
+    for (const key of DESIGN_ASSIST_CAPABILITIES) {
+      if (!explicitCapabilityKeys.has(key)) capabilities[key] = "assist";
+    }
+  }
+  const creativeEfficiency = argv.includes("--creative-efficiency");
+  const fileExplicitOff = fileConfig.mode === "off" && modeIdx < 0 && !envMode;
+  if (creativeEfficiency && !explicitOff && !fileExplicitOff) {
+    if (mode === "off") mode = "assist";
+    for (const key of CREATIVE_EFFICIENCY_CAPABILITIES) {
+      if (!explicitCapabilityKeys.has(key)) capabilities[key] = "assist";
+    }
+  }
+  let compactPackets = fileConfig.compactPackets ?? DEFAULT_JEV_CONFIG.compactPackets;
+  if (env.VITRIS_COMPACT_PACKETS !== void 0) {
+    compactPackets = env.VITRIS_COMPACT_PACKETS === "true" || env.VITRIS_COMPACT_PACKETS === "1";
+  }
+  if (argv.includes("--compact-packets")) {
+    compactPackets = true;
+  } else if (argv.includes("--no-compact-packets")) {
+    compactPackets = false;
+  } else if (creativeEfficiency && fileConfig.compactPackets !== false && env.VITRIS_COMPACT_PACKETS !== "false" && env.VITRIS_COMPACT_PACKETS !== "0") {
+    compactPackets = true;
+  }
+  let model = fileConfig.model || DEFAULT_JEV_CONFIG.model;
+  if (env.VITRIS_JEV_MODEL?.trim()) {
+    model = env.VITRIS_JEV_MODEL.trim();
+  }
+  const modelIdx = argv.indexOf("--jev-model");
+  if (modelIdx >= 0 && argv[modelIdx + 1]?.trim()) {
+    model = argv[modelIdx + 1].trim();
+  }
+  const confidenceThresholds = {
+    routing: fileConfig.confidenceThresholds?.routing ?? DEFAULT_JEV_CONFIG.confidenceThresholds.routing,
+    grounding: fileConfig.confidenceThresholds?.grounding ?? DEFAULT_JEV_CONFIG.confidenceThresholds.grounding
+  };
+  let workOwnership = fileConfig.workOwnership ?? "agent";
+  const envOwnership = env.VITRIS_JEV_WORK_OWNERSHIP?.toLowerCase();
+  if (envOwnership === "agent" || envOwnership === "delegated") {
+    workOwnership = envOwnership;
+  }
+  const ownershipIdx = argv.indexOf("--jev-work-ownership");
+  if (ownershipIdx >= 0 && argv[ownershipIdx + 1]) {
+    const raw = argv[ownershipIdx + 1].toLowerCase();
+    if (raw === "agent" || raw === "delegated") {
+      workOwnership = raw;
+    }
+  }
+  const config = {
+    mode,
+    model,
+    endpoint: fileConfig.endpoint || env.TYPESAFE_BASE_URL || void 0,
+    timeoutMs: fileConfig.timeoutMs ?? DEFAULT_JEV_CONFIG.timeoutMs,
+    taskDeadlineMs: fileConfig.taskDeadlineMs ?? DEFAULT_JEV_CONFIG.taskDeadlineMs,
+    maxConcurrency: fileConfig.maxConcurrency ?? DEFAULT_JEV_CONFIG.maxConcurrency,
+    maxRetries: fileConfig.maxRetries ?? DEFAULT_JEV_CONFIG.maxRetries,
+    confidenceThresholds,
+    compactPackets,
+    cache: fileConfig.cache || { enabled: true, dir: join(root, "agent/decisions/jev/cache") },
+    budget: fileConfig.budget || {},
+    capabilities,
+    telemetry: fileConfig.telemetry || { enabled: true, receiptDir: join(root, "agent/decisions/jev") },
+    workOwnership,
+    pilotBudget: fileConfig.pilotBudget || { ...DEFAULT_PILOT_BUDGET },
+    calibrationGates: fileConfig.calibrationGates || [],
+    taskApplicability: fileConfig.taskApplicability || []
+  };
+  validateJevConfig(config);
+  return config;
+}
+function validateJevConfig(config) {
+  const validModes = ["off", "shadow", "assist"];
+  if (!validModes.includes(config.mode)) {
+    throw new Error(`Invalid JevConfig.mode: "${config.mode}". Allowed: off, shadow, assist.`);
+  }
+  if (config.workOwnership !== void 0 && !["agent", "delegated"].includes(config.workOwnership)) {
+    throw new Error(`Invalid JevConfig.workOwnership: "${config.workOwnership}". Allowed: agent, delegated.`);
+  }
+  if (config.capabilities) {
+    for (const [key, val] of Object.entries(config.capabilities)) {
+      if (!validModes.includes(val)) {
+        throw new Error(`Invalid JevConfig.capabilities.${key}: "${val}". Allowed: off, shadow, assist.`);
+      }
+    }
+  }
+  if (config.confidenceThresholds) {
+    const { routing, grounding } = config.confidenceThresholds;
+    if (typeof routing !== "number" || routing < 0 || routing > 1) {
+      throw new Error(`Invalid JevConfig.confidenceThresholds.routing: ${routing}. Must be [0, 1].`);
+    }
+    if (typeof grounding !== "number" || grounding < 0 || grounding > 1) {
+      throw new Error(`Invalid JevConfig.confidenceThresholds.grounding: ${grounding}. Must be [0, 1].`);
+    }
+  }
+  if (config.pilotBudget) {
+    if (typeof config.pilotBudget.maxTransportAttempts !== "number" || config.pilotBudget.maxTransportAttempts <= 0) {
+      throw new Error(`Invalid JevConfig.pilotBudget.maxTransportAttempts: ${config.pilotBudget.maxTransportAttempts}. Must be a positive number.`);
+    }
+    if (typeof config.pilotBudget.maxInputTokens !== "number" || config.pilotBudget.maxInputTokens <= 0) {
+      throw new Error(`Invalid JevConfig.pilotBudget.maxInputTokens: ${config.pilotBudget.maxInputTokens}. Must be a positive number.`);
+    }
+  }
+}
+function resolveCapability(config, capability) {
+  const modeRank = { off: 0, shadow: 1, assist: 2 };
+  const globalMode = config.mode;
+  const capMode = config.capabilities?.[capability] ?? "off";
+  return modeRank[capMode] <= modeRank[globalMode] ? capMode : globalMode;
+}
+function resolveEffectiveCapabilities(config) {
+  return {
+    mediaClassification: resolveCapability(config, "mediaClassification"),
+    mediaSelection: resolveCapability(config, "mediaSelection"),
+    mediaSetReview: resolveCapability(config, "mediaSetReview"),
+    mediaProvenance: resolveCapability(config, "mediaProvenance"),
+    grounding: resolveCapability(config, "grounding"),
+    sourceSelection: resolveCapability(config, "sourceSelection"),
+    retrievalRanking: resolveCapability(config, "retrievalRanking"),
+    consistency: resolveCapability(config, "consistency"),
+    repairAssistance: resolveCapability(config, "repairAssistance"),
+    preferenceScoring: resolveCapability(config, "preferenceScoring"),
+    // Workstream 5
+    claimStrengthening: resolveCapability(config, "claimStrengthening"),
+    ctaFidelity: resolveCapability(config, "ctaFidelity"),
+    crossStageContinuity: resolveCapability(config, "crossStageContinuity"),
+    coverageCheck: resolveCapability(config, "coverageCheck"),
+    // Workstream 7
+    creativeScoring: resolveCapability(config, "creativeScoring"),
+    componentSelection: resolveCapability(config, "componentSelection"),
+    compositionCheck: resolveCapability(config, "compositionCheck"),
+    lessonRanking: resolveCapability(config, "lessonRanking"),
+    visitorQuestionCheck: resolveCapability(config, "visitorQuestionCheck"),
+    factContradictionCheck: resolveCapability(config, "factContradictionCheck"),
+    ctaFitCheck: resolveCapability(config, "ctaFitCheck"),
+    repetitionExplanationCheck: resolveCapability(config, "repetitionExplanationCheck"),
+    directionContinuityCheck: resolveCapability(config, "directionContinuityCheck")
+  };
+}
+var JEV_CLIENT_CAPABILITIES = [
+  "mediaClassification",
+  "mediaSelection",
+  "mediaSetReview",
+  "mediaProvenance",
+  "grounding",
+  "sourceSelection",
+  "retrievalRanking",
+  "coverageCheck",
+  "ctaFidelity",
+  "claimStrengthening",
+  "crossStageContinuity",
+  "creativeScoring",
+  "componentSelection",
+  "compositionCheck",
+  "lessonRanking",
+  "visitorQuestionCheck",
+  "factContradictionCheck",
+  "ctaFitCheck",
+  "repetitionExplanationCheck",
+  "directionContinuityCheck"
+];
+function jevClientRequired(config) {
+  if (config.mode === "off") return false;
+  const caps = resolveEffectiveCapabilities(config);
+  return JEV_CLIENT_CAPABILITIES.some((key) => caps[key] !== "off");
+}
+function snapshotEffectiveConfig(config) {
+  const caps = resolveEffectiveCapabilities(config);
+  const snapshot = {};
+  for (const [k, v] of Object.entries(caps)) {
+    snapshot[k] = v;
+  }
+  snapshot["_workOwnership"] = config.workOwnership ?? "agent";
+  snapshot["_mode"] = config.mode;
+  return snapshot;
+}
+
+// src/agent/jev/policy.ts
+var POLICY_VERSION = "2026-09-17.2";
+function evaluateTaskApplicability(taskId, applicabilityDescriptors, siteContext) {
+  if (!applicabilityDescriptors || applicabilityDescriptors.length === 0) {
+    return { applicable: true };
+  }
+  const descriptor = applicabilityDescriptors.find((a) => a.taskId === taskId);
+  if (!descriptor) {
+    return { applicable: true };
+  }
+  const subjectExists = siteContext?.subjectExists ?? descriptor.subjectExists;
+  if (!subjectExists) {
+    return {
+      applicable: false,
+      skipReason: `Task "${taskId}" subject does not exist on this site (riskLevel: ${descriptor.riskLevel})`
+    };
+  }
+  return { applicable: true };
+}
+function evaluateGroundingVerdict(opts) {
+  const threshold = opts.threshold ?? DEFAULT_GROUNDING_CONFIDENCE_THRESHOLD;
+  if (!opts.codeCheck.sourceExists) {
+    return {
+      verdict: "missing_source",
+      autoAccepted: true,
+      notes: "Cited source file is absent from repository; code preflight failed."
+    };
+  }
+  if (opts.codeCheck.excerptLength === 0) {
+    return {
+      verdict: "insufficient_evidence",
+      autoAccepted: true,
+      notes: "Cited evidence excerpt is empty; cannot verify claim."
+    };
+  }
+  if (!opts.codeCheck.quoteFound) {
+    return {
+      verdict: "quote_not_found",
+      autoAccepted: true,
+      notes: "Declared quote could not be located verbatim in cited source text."
+    };
+  }
+  if (!opts.relationChoice) {
+    return {
+      verdict: "insufficient_evidence",
+      autoAccepted: false,
+      notes: "No semantic evaluation available; requires critic verification."
+    };
+  }
+  const confidence = opts.confidence ?? 0;
+  const highConfidence = confidence >= threshold;
+  if (opts.relationChoice === "contradicts") {
+    return {
+      verdict: "contradicted",
+      autoAccepted: highConfidence,
+      notes: `Evidence excerpt directly contradicts claim (confidence: ${(confidence * 100).toFixed(1)}%). Major defect.`
+    };
+  }
+  if (opts.relationChoice === "supports") {
+    if (highConfidence) {
+      return {
+        verdict: "verified",
+        autoAccepted: true,
+        notes: `Evidence excerpt supports claim (confidence: ${(confidence * 100).toFixed(1)}%).`
+      };
+    } else {
+      return {
+        verdict: "insufficient_evidence",
+        autoAccepted: false,
+        notes: `Excerpt tentatively supports claim but confidence ${(confidence * 100).toFixed(1)}% is below threshold ${(threshold * 100).toFixed(1)}%; critic review required.`
+      };
+    }
+  }
+  return {
+    verdict: "insufficient_evidence",
+    autoAccepted: highConfidence,
+    notes: `Evidence excerpt does not address claim (confidence: ${(confidence * 100).toFixed(1)}%).`
+  };
+}
+function evaluateRoutingDecision(opts) {
+  const threshold = opts.threshold ?? DEFAULT_ROUTING_CONFIDENCE_THRESHOLD;
+  if (opts.overrideScope) {
+    return {
+      scope: opts.overrideScope,
+      isMixed: false,
+      isAmbiguous: false,
+      confidence: 1,
+      autoAccepted: true,
+      rationale: `Explicit operator override --change-scope ${opts.overrideScope} applied.`
+    };
+  }
+  if (opts.choice === "mixed") {
+    return {
+      scope: opts.fallbackScope === "business" ? "business" : "pages",
+      isMixed: true,
+      isAmbiguous: false,
+      confidence: opts.confidence,
+      autoAccepted: opts.confidence >= threshold,
+      rationale: "Request combines multiple scopes; union of affected stages required."
+    };
+  }
+  if (opts.choice === "ambiguous" || opts.confidence < threshold) {
+    return {
+      scope: opts.fallbackScope,
+      isMixed: false,
+      isAmbiguous: true,
+      confidence: opts.confidence,
+      autoAccepted: false,
+      rationale: `Model classification (${opts.choice}, ${(opts.confidence * 100).toFixed(1)}%) is below threshold ${(threshold * 100).toFixed(1)}%; falling back to baseline scope ${opts.fallbackScope}.`
+    };
+  }
+  const validScope = opts.choice;
+  return {
+    scope: validScope,
+    isMixed: false,
+    isAmbiguous: false,
+    confidence: opts.confidence,
+    autoAccepted: true,
+    rationale: `Classified as ${validScope} (confidence: ${(opts.confidence * 100).toFixed(1)}%).`
+  };
+}
+function requestNodesForScope(scope) {
+  if (scope === "business") return ["business", "copy", "pages"];
+  if (scope === "direction") return ["direction", "storyboard", "copy", "representative", "pages"];
+  if (scope === "copy") return ["copy", "pages"];
+  if (scope === "media") return ["media", "representative", "pages"];
+  return ["pages"];
+}
+function unionNodesForScopes(scopes) {
+  const nodeOrder = ["business", "media", "direction", "storyboard", "copy", "representative", "pages"];
+  const needed = /* @__PURE__ */ new Set();
+  for (const s of scopes) {
+    for (const n of requestNodesForScope(s)) {
+      needed.add(n);
+    }
+  }
+  return nodeOrder.filter((n) => needed.has(n));
+}
+function evaluateMultiScopeDecision(opts) {
+  const threshold = opts.threshold ?? DEFAULT_ROUTING_CONFIDENCE_THRESHOLD;
+  if (opts.overrideScope) {
+    const override = opts.overrideScope;
+    return {
+      scope: override,
+      scopes: [override],
+      isMixed: false,
+      isAmbiguous: false,
+      confidence: 1,
+      autoAccepted: true,
+      rationale: `Explicit operator override --change-scope ${override} applied.`,
+      affectedNodes: requestNodesForScope(override)
+    };
+  }
+  const scores = {
+    business: opts.answers.business?.noul ?? 0,
+    copy: opts.answers.copy?.noul ?? 0,
+    pages: opts.answers.pages?.noul ?? 0,
+    direction: opts.answers.direction?.noul ?? 0,
+    media: 0
+  };
+  const activeScopes = ["business", "direction", "copy", "pages"].filter((s) => scores[s] >= threshold);
+  if (activeScopes.length > 1) {
+    const primaryScope = activeScopes[0];
+    const affected = unionNodesForScopes(activeScopes);
+    const maxConf = Math.max(...activeScopes.map((s) => scores[s]));
+    return {
+      scope: primaryScope,
+      scopes: activeScopes,
+      isMixed: true,
+      isAmbiguous: false,
+      confidence: maxConf,
+      autoAccepted: true,
+      rationale: `Request affects multiple scopes: [${activeScopes.join(", ")}]; union of affected stages (${affected.join(" -> ")}) planned.`,
+      affectedNodes: affected
+    };
+  }
+  if (activeScopes.length === 1) {
+    const singleScope = activeScopes[0];
+    return {
+      scope: singleScope,
+      scopes: activeScopes,
+      isMixed: false,
+      isAmbiguous: false,
+      confidence: scores[singleScope],
+      autoAccepted: true,
+      rationale: `Classified as ${singleScope} (confidence: ${(scores[singleScope] * 100).toFixed(1)}%).`,
+      affectedNodes: requestNodesForScope(singleScope)
+    };
+  }
+  const highestConf = Math.max(scores.business, scores.copy, scores.pages, scores.direction);
+  return {
+    scope: opts.fallbackScope,
+    scopes: [opts.fallbackScope],
+    isMixed: false,
+    isAmbiguous: true,
+    confidence: highestConf,
+    autoAccepted: false,
+    rationale: `No scope reached confidence threshold ${(threshold * 100).toFixed(1)}% (max: ${(highestConf * 100).toFixed(1)}%); falling back to baseline scope ${opts.fallbackScope}.`,
+    affectedNodes: requestNodesForScope(opts.fallbackScope)
+  };
+}
+
+export {
+  DEFAULT_JEV_MODEL,
+  DEFAULT_JEV_CONFIG,
+  DEFAULT_PILOT_BUDGET,
+  resolveApiKey,
+  loadJevConfig,
+  resolveCapability,
+  resolveEffectiveCapabilities,
+  jevClientRequired,
+  snapshotEffectiveConfig,
+  POLICY_VERSION,
+  evaluateTaskApplicability,
+  evaluateGroundingVerdict,
+  evaluateRoutingDecision,
+  requestNodesForScope,
+  unionNodesForScopes,
+  evaluateMultiScopeDecision
+};

package/bin/chunks/chunk-6A3VWYMF.js

@@ -0,0 +1,28 @@
+// src/knowledge/evidence.ts
+import { createHash } from "node:crypto";
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, canonical(entry)]));
+  }
+  return value;
+}
+function digestOf(receipt) {
+  const { digest: _ignored, ...body } = receipt;
+  return createHash("sha256").update(JSON.stringify(canonical(body))).digest("hex");
+}
+function sealReceipt(receipt) {
+  return { ...receipt, digest: digestOf(receipt) };
+}
+function verifyReceipt(receipt) {
+  const expected = digestOf(receipt);
+  if (expected !== receipt.digest) return { ok: false, reason: "Receipt digest does not match its findings." };
+  const failed = receipt.findings.some((item) => item.status === "fail" || item.status === "tool-error" || item.status === "stale");
+  if (receipt.passed === true && failed) return { ok: false, reason: "A passed flag cannot override a failing finding." };
+  return { ok: true };
+}
+
+export {
+  sealReceipt,
+  verifyReceipt
+};

package/bin/chunks/chunk-6H3T46F5.js

@@ -0,0 +1,25 @@
+// src/agent/composition-authoring.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var COMPOSITION_LESSON_RELEASE = "2026-09-28.1";
+function resolveDesignAuthoring(root) {
+  const path = join(root, "launch.json");
+  const launch = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+  const raw = launch.designAuthoring;
+  if (raw === void 0) return policy("blocks-v0", null);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("launch.json designAuthoring must be an object");
+  const config = raw;
+  if (config.mode === "blocks-v0" && (config.lessonRelease === void 0 || config.lessonRelease === null)) return policy("blocks-v0", null);
+  if (config.mode === "composition-v1" && config.lessonRelease === COMPOSITION_LESSON_RELEASE) return policy("composition-v1", COMPOSITION_LESSON_RELEASE);
+  throw new Error(`Unsupported launch.json designAuthoring mode/release: ${String(config.mode)}/${String(config.lessonRelease)}. Use blocks-v0, or composition-v1 with ${COMPOSITION_LESSON_RELEASE}.`);
+}
+function policy(mode, lessonRelease) {
+  const hash = createHash("sha256").update(JSON.stringify({ mode, lessonRelease })).digest("hex");
+  return { mode, lessonRelease, hash };
+}
+
+export {
+  COMPOSITION_LESSON_RELEASE,
+  resolveDesignAuthoring
+};

package/bin/chunks/chunk-7FS67SRF.js

@@ -0,0 +1,12 @@
+// src/html.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttr(value) {
+  return escapeHtml(value);
+}
+
+export {
+  escapeHtml,
+  escapeAttr
+};

package/bin/chunks/chunk-7VLBEAFW.js

@@ -0,0 +1,56 @@
+import {
+  EXIT_CODES
+} from "./chunk-JCRGE6AL.js";
+import {
+  applyKitUpgrade,
+  planKitUpgrade,
+  recoverKitUpgrade,
+  rollbackKitUpgrade
+} from "./chunk-3CTBXY5K.js";
+import {
+  findHarnessRoot
+} from "./chunk-HNORQ74T.js";
+import {
+  json,
+  save
+} from "./chunk-T6PE4KN4.js";
+
+// src/cli/upgrade.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+function upgradeSite(opts) {
+  const root = resolve(opts.site || "."), target = resolve(opts.target || findHarnessRoot());
+  try {
+    if (opts.recover) {
+      const result = recoverKitUpgrade(root);
+      return { ok: true, exitCode: EXIT_CODES.SUCCESS, summary: `Kit recovery: ${result.status}`, data: result };
+    }
+    if (opts.rollback) {
+      const result = rollbackKitUpgrade(root);
+      return { ok: true, exitCode: EXIT_CODES.SUCCESS, summary: "Managed kit rolled back", data: result };
+    }
+    const version = JSON.parse(readFileSync(join(target, "package.json"), "utf8")).version;
+    if (opts.to && opts.to !== version) throw new Error(`Target ${opts.to} is unavailable at ${target}; provide an installed package directory with --target`);
+    if (opts.apply) {
+      const path = join(root, "agent/kit-upgrade-plan.json");
+      if (!existsSync(path)) throw new Error("Run upgrade --plan before --apply");
+      const plan2 = json(path);
+      const result = applyKitUpgrade(root, target, plan2);
+      return { ok: true, exitCode: EXIT_CODES.SUCCESS, summary: `Managed kit updated to ${version}; existing graph progress retained`, data: result };
+    }
+    const plan = planKitUpgrade(root, target);
+    save(join(root, "agent/kit-upgrade-plan.json"), plan);
+    return {
+      ok: plan.conflicts.length === 0,
+      exitCode: plan.conflicts.length ? EXIT_CODES.PRECONDITION_FAILED : EXIT_CODES.SUCCESS,
+      summary: `Managed kit plan: ${plan.updates.length} updates, ${plan.additions.length} additions, ${plan.conflicts.length} conflicts`,
+      data: plan
+    };
+  } catch (error) {
+    return { ok: false, exitCode: EXIT_CODES.PRECONDITION_FAILED, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export {
+  upgradeSite
+};

package/bin/chunks/chunk-ANMJRJQ5.js

@@ -0,0 +1,31 @@
+// src/compile/frontmatter.ts
+function parseFrontmatter(raw) {
+  const text = raw.replace(/^\uFEFF/, "");
+  if (!text.startsWith("---")) {
+    return { meta: {}, body: text.trim() };
+  }
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) {
+    return { meta: {}, body: text.trim() };
+  }
+  const block = text.slice(3, end).trim();
+  const body = text.slice(end + 4).replace(/^\r?\n/, "");
+  const meta = {};
+  for (const line of block.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) continue;
+    const key = trimmed.slice(0, colon).trim();
+    let value = trimmed.slice(colon + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) meta[key] = value;
+  }
+  return { meta, body: body.trim() };
+}
+
+export {
+  parseFrontmatter
+};