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

package/bin/chunks/chunk-BBV7PMFC.js

@@ -0,0 +1,185 @@
+// src/agent/graph.ts
+function unquote(s) {
+  const t = s.trim();
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  return t;
+}
+function parseInlineList(raw) {
+  const inner = raw.trim().replace(/^\[/, "").replace(/\]$/, "").trim();
+  if (!inner) return [];
+  return inner.split(",").map((p) => unquote(p.trim())).filter(Boolean);
+}
+function parseGraphYaml(text) {
+  if (text.trimStart().startsWith("{")) {
+    const graph2 = JSON.parse(text);
+    validateGraph(graph2);
+    return graph2;
+  }
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  let version = 1;
+  let stopAt = "preview_ready";
+  const nodes = [];
+  let current = null;
+  let listKey = null;
+  const flush = () => {
+    if (!current?.id) return;
+    nodes.push({
+      id: current.id,
+      needs: current.needs || [],
+      tools: current.tools || [],
+      writes: current.writes || [],
+      eval: current.eval || current.id,
+      maxAttempts: current.maxAttempts ?? 3,
+      refs: current.refs || [],
+      optional: current.optional
+    });
+    current = null;
+    listKey = null;
+  };
+  for (const raw of lines) {
+    const line = raw.replace(/#.*$/, "");
+    if (!line.trim()) continue;
+    const indent = raw.match(/^\s*/)?.[0].length ?? 0;
+    if (indent === 0 && line.startsWith("version:")) {
+      version = Number(unquote(line.slice("version:".length))) || 1;
+      continue;
+    }
+    if (indent === 0 && line.startsWith("stop_at:")) {
+      stopAt = unquote(line.slice("stop_at:".length));
+      continue;
+    }
+    if (indent === 0 && line.startsWith("nodes:")) {
+      continue;
+    }
+    if (/^\s*-\s+id:/.test(line)) {
+      flush();
+      current = { id: unquote(line.replace(/^\s*-\s+id:/, "")) };
+      listKey = null;
+      continue;
+    }
+    if (!current) continue;
+    if (indent >= 4 && listKey && /^\s*-\s+/.test(line)) {
+      const val = unquote(line.replace(/^\s*-\s+/, ""));
+      current[listKey] = [...current[listKey] || [], val];
+      continue;
+    }
+    const m = line.match(/^\s+([a-zA-Z_]+):\s*(.*)$/);
+    if (!m) continue;
+    const key = m[1];
+    const rest = m[2].trim();
+    if (key === "needs" || key === "tools" || key === "writes" || key === "refs") {
+      if (rest.startsWith("[")) {
+        current[key] = parseInlineList(rest);
+        listKey = null;
+      } else if (!rest) {
+        current[key] = [];
+        listKey = key;
+      } else {
+        current[key] = [unquote(rest)];
+        listKey = null;
+      }
+      continue;
+    }
+    listKey = null;
+    if (key === "eval") current.eval = unquote(rest);
+    if (key === "maxAttempts") current.maxAttempts = Number(unquote(rest)) || 3;
+    if (key === "optional") current.optional = rest === "true";
+  }
+  flush();
+  const graph = { version, stop_at: stopAt, nodes };
+  validateGraph(graph);
+  return graph;
+}
+function nextNode(graph, state, opts) {
+  if (state.status === "repeated_failure_blocked") throw new Error("Repeated failure blocked. Repair the cause, then use --restart-from NODE --reason to explicitly reopen the stage.");
+  for (const node of graph.nodes) {
+    if (node.optional && !opts?.includeOptional) continue;
+    const st = state.nodes[node.id];
+    if (st?.status === "done") continue;
+    const ready = node.needs.every((n) => state.nodes[n]?.status === "done");
+    if (ready) {
+      if ((st?.attempts || 0) >= node.maxAttempts) throw new Error(`Node ${node.id} exhausted ${node.maxAttempts} attempts`);
+      return node;
+    }
+  }
+  return null;
+}
+function isPreviewReady(graph, state) {
+  const stop = graph.stop_at === "preview_ready" ? "preview" : graph.stop_at;
+  return graph.nodes.filter((n) => !n.optional).every((n) => state.nodes[n.id]?.status === "done") && state.nodes[stop]?.status === "done";
+}
+function validateGraph(graph) {
+  if (![1, 2, 3].includes(graph.version) || !Array.isArray(graph.nodes) || !graph.nodes.length) throw new Error("Invalid graph version/nodes");
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    if (!/^[a-z][a-z0-9-]*$/.test(node.id) || ids.has(node.id)) throw new Error(`Invalid/duplicate node: ${node.id}`);
+    ids.add(node.id);
+    if (!Number.isInteger(node.maxAttempts) || node.maxAttempts < 1) throw new Error(`Invalid attempts: ${node.id}`);
+    if (!Array.isArray(node.needs) || !Array.isArray(node.refs) || !Array.isArray(node.writes)) throw new Error(`Invalid node contract: ${node.id}`);
+    if (graph.version >= 2 && node.kind && !["tool", "agent", "critic"].includes(node.kind)) throw new Error(`Invalid node kind: ${node.id}`);
+    if (node.kind === "tool" && (!Array.isArray(node.command) || !node.command.length || node.command.some((a) => typeof a !== "string"))) throw new Error(`Invalid tool command: ${node.id}`);
+  }
+  const visited = /* @__PURE__ */ new Set(), visiting = /* @__PURE__ */ new Set();
+  function visit(id) {
+    if (!ids.has(id)) throw new Error(`Unknown dependency: ${id}`);
+    if (visiting.has(id)) throw new Error(`Cycle: ${id}`);
+    if (visited.has(id)) return;
+    visiting.add(id);
+    for (const dep of graph.nodes.find((n) => n.id === id).needs) visit(dep);
+    visiting.delete(id);
+    visited.add(id);
+  }
+  for (const node of graph.nodes) {
+    visit(node.id);
+    if (!node.optional && node.needs.some((id) => graph.nodes.find((n) => n.id === id)?.optional)) throw new Error(`Required node depends on optional node: ${node.id}`);
+    if (node.repair && !ids.has(node.repair)) throw new Error(`Unknown repair target: ${node.repair}`);
+    if (node.historicalAfter && !ids.has(node.historicalAfter)) throw new Error(`Unknown historical successor: ${node.historicalAfter}`);
+  }
+  if (!ids.has(graph.stop_at === "preview_ready" ? "preview" : graph.stop_at)) throw new Error("Unknown stop target");
+}
+function initialState(graph) {
+  return {
+    version: graph.version,
+    status: "pending",
+    current: null,
+    preview_ready: false,
+    launched: false,
+    iteration: 0,
+    cumulativeSpend: { iterations: 0, calls: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 },
+    nodes: Object.fromEntries(graph.nodes.map((n) => [n.id, { status: "pending", attempts: 0 }]))
+  };
+}
+function invalidate(graph, state, id) {
+  const affected = /* @__PURE__ */ new Set([id]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const node of graph.nodes) {
+      if (!affected.has(node.id) && node.needs.some((n) => affected.has(n))) {
+        const isHistorical = node.historicalAfter && (state.nodes[node.historicalAfter]?.attempts || 0) > 0 && state.nodes[node.id]?.status === "done";
+        if (!isHistorical) {
+          affected.add(node.id);
+          changed = true;
+        }
+      }
+    }
+  }
+  for (const key of affected) {
+    const previous = state.nodes[key];
+    state.nodes[key] = { status: "pending", attempts: previous?.attempts || 0, ...previous?.invocationBaseline !== void 0 ? { invocationBaseline: previous.invocationBaseline } : {} };
+  }
+  state.preview_ready = false;
+  state.launched = false;
+  state.status = "in_progress";
+}
+
+export {
+  parseGraphYaml,
+  nextNode,
+  isPreviewReady,
+  validateGraph,
+  initialState,
+  invalidate
+};

package/bin/chunks/chunk-BIEDSEL2.js

@@ -0,0 +1,8 @@
+// src/knowledge/contracts.ts
+var KNOWLEDGE_RELEASE = "2026-09-22";
+var LAUNCH_POLICY_ID = "vitris-launch-2026-09-22";
+
+export {
+  KNOWLEDGE_RELEASE,
+  LAUNCH_POLICY_ID
+};

package/bin/chunks/chunk-CBEJZO4L.js

@@ -0,0 +1,67 @@
+import {
+  findActivePreparation,
+  loadKnowledgeCatalog,
+  loadPersistedDesignContextPacket,
+  selectLessonsForStage,
+  selectStageKnowledge,
+  signalsFromSite,
+  siteWidgets
+} from "./chunk-3CTBXY5K.js";
+import {
+  coverageReport,
+  loadKnowledgeV2
+} from "./chunk-R7YELY3C.js";
+import {
+  KNOWLEDGE_RELEASE
+} from "./chunk-BIEDSEL2.js";
+
+// src/knowledge/explain.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function explainStage(root, stage) {
+  const pack = loadKnowledgeV2(root);
+  const validPack = pack && pack.errors.length === 0 ? pack : void 0;
+  const catalog = loadKnowledgeCatalog(root);
+  const lessons = catalog ? selectLessonsForStage(root, stage) : [];
+  let story;
+  const storyPath = join(root, "onboarding/storyboard.json");
+  if (existsSync(storyPath)) try {
+    story = JSON.parse(readFileSync(storyPath, "utf8"));
+  } catch {
+  }
+  const signals = { ...signalsFromSite(root), widgets: siteWidgets(root, story).widgets };
+  const selected = selectStageKnowledge({
+    requirements: validPack?.requirements || [],
+    lessons,
+    signals,
+    stage
+  });
+  const preparation = findActivePreparation(root, stage);
+  const actual = preparation ? loadPersistedDesignContextPacket(root, preparation.id)?.manifest : void 0;
+  const actualRequirements = actual?.selectedRequirements ? actual.selectedRequirements.map((entry) => validPack?.requirements.find((item) => item.id === entry.id)).filter((item) => !!item) : selected.requirements;
+  const actualLessons = actual?.selectedLessons ? actual.selectedLessons.map((entry) => lessons.find((item) => item.id === entry.id)).filter((item) => !!item) : selected.lessons;
+  const lines = [
+    `Knowledge release ${pack?.release || KNOWLEDGE_RELEASE}`,
+    `Stage ${stage}`,
+    ...actual ? [`Active preparation ${preparation.id}: these are the recorded live selections.`] : ["No active preparation: these are prospective selections."],
+    "Mandatory and applicable requirements:",
+    ...actualRequirements.map((item) => `- ${item.id} [${item.authorityClass}/${item.severityPolicy}/${item.implementationStatus}] ${item.instruction}`),
+    "Eligible lessons:",
+    ...actualLessons.map((item) => `- ${item.id} because ${item.reason}`)
+  ];
+  if (!pack) lines.push("v2 pack did not load. Lesson ids from v1 are still listed when the catalog verifies.");
+  if (pack?.errors.length) lines.push(`v2 pack quarantined: ${pack.errors.join("; ")}`);
+  if (pack && coverageReport(pack).missingClassification.length) {
+    lines.push(`Unclassified requirements: ${coverageReport(pack).missingClassification.join(", ")}`);
+  }
+  return {
+    text: lines.join("\n"),
+    release: pack?.release || KNOWLEDGE_RELEASE,
+    lessonIds: actual?.selectedLessons.map((item) => item.id) || selected.lessons.map((item) => item.id),
+    requirementIds: actual?.selectedRequirements.map((item) => item.id) || selected.requirements.map((item) => item.id)
+  };
+}
+
+export {
+  explainStage
+};