@kungfu-tech/kfd 1.0.0-alpha.2 → 1.0.0-alpha.21

package/scripts/update-kfd-3-witness.mjs

@@ -0,0 +1,261 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import crypto from "node:crypto";
+import path from "node:path";
+
+const interfacePath = ".buildchain/kfd-3/collaboration-interface.json";
+const prebuildPath = ".buildchain/kfd-3/collaboration-interface.prebuild.json";
+const artifactPath = ".buildchain/kfd-3/collaboration-interface.artifact.json";
+
+const readJson = (filePath) => JSON.parse(readFileSync(filePath, "utf8"));
+const sha256File = (filePath) => crypto.createHash("sha256").update(readFileSync(filePath)).digest("hex");
+const hashablePath = (filePath) => filePath.split("#", 1)[0];
+const pointer = (filePath, description = undefined) => ({
+  path: filePath,
+  sha256: sha256File(hashablePath(filePath)),
+  ...(description ? { description } : {}),
+});
+
+const writeJson = (filePath, value) => {
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+};
+
+const packageJson = readJson("package.json");
+const registry = readJson("registry.json");
+const standards = readJson("standards.json");
+const collaborationInterface = readJson(interfacePath);
+const interfaceSha = sha256File(interfacePath);
+const interfaceDigest = `sha256:${interfaceSha}`;
+
+const decisionDocs = registry.entries.map((entry) => ({
+  id: `decision:${entry.slug}`,
+  sourcePath: entry.path,
+  sha256: sha256File(entry.path),
+}));
+const schemaSurfaces = [
+  "schemas/kfd-standards.schema.json",
+  "schemas/kfd-1/contract-world.schema.json",
+  "schemas/kfd-1/witness.schema.json",
+  "schemas/kfd-2/trust-taxonomy.schema.json",
+  "schemas/kfd-2/trust-claims.schema.json",
+  "schemas/kfd-2/trust-assessment.schema.json",
+  "schemas/kfd-2/release-claims.schema.json",
+  "schemas/kfd-2/release-trust-passport.schema.json",
+  "schemas/kfd-3/collaboration-interface.schema.json",
+  "schemas/kfd-3/witness.schema.json",
+  "schemas/kfd-4/observer-perspective.schema.json",
+].map((filePath) => ({
+  id: `schema:${filePath.replace(/^schemas\//, "").replace(/\.schema\.json$/, "").replace(/\//g, ":")}`,
+  sourcePath: filePath,
+  sha256: sha256File(filePath),
+}));
+
+const groupedSurfaces = {
+  docs: [
+    { id: "doc:readme", sourcePath: "README.md", sha256: sha256File("README.md") },
+    { id: "doc:trademarks", sourcePath: "TRADEMARKS.md", sha256: sha256File("TRADEMARKS.md") },
+    { id: "doc:docs-map", sourcePath: "docs/MAP.md", sha256: sha256File("docs/MAP.md") },
+    { id: "doc:kfd-1-usage", sourcePath: "docs/KFD-1-usage.md", sha256: sha256File("docs/KFD-1-usage.md") },
+    { id: "doc:kfd-2-usage", sourcePath: "docs/KFD-2-usage.md", sha256: sha256File("docs/KFD-2-usage.md") },
+    { id: "doc:kfd-3-usage", sourcePath: "docs/KFD-3-usage.md", sha256: sha256File("docs/KFD-3-usage.md") },
+    { id: "doc:kfd-4-usage", sourcePath: "docs/KFD-4-usage.md", sha256: sha256File("docs/KFD-4-usage.md") },
+    ...decisionDocs,
+  ],
+  schemas: schemaSurfaces,
+  standardsMetadata: [
+    { id: "metadata:registry", sourcePath: "registry.json", sha256: sha256File("registry.json") },
+    { id: "metadata:standards", sourcePath: "standards.json", sha256: sha256File("standards.json") },
+    { id: "metadata:release-impact", sourcePath: "release-impact.json", sha256: sha256File("release-impact.json") },
+    { id: "metadata:release-anchor", sourcePath: "kfd.release.json", sha256: sha256File("kfd.release.json") },
+    { id: "metadata:buildchain-contract-lock", sourcePath: "buildchain.contract-lock.json", sha256: sha256File("buildchain.contract-lock.json") },
+    { id: "metadata:kfd-2-public-release-trust-claim", sourcePath: ".buildchain/kfd-2/public-release-trust.claim.json", sha256: sha256File(".buildchain/kfd-2/public-release-trust.claim.json") },
+    { id: "metadata:kfd-2-foundation-trust-claims", sourcePath: ".buildchain/kfd-2/kfd-foundation.trust-claims.json", sha256: sha256File(".buildchain/kfd-2/kfd-foundation.trust-claims.json") },
+    { id: "metadata:kfd-2-foundation-trust-assessment", sourcePath: ".buildchain/kfd-2/kfd-foundation.trust-assessment.json", sha256: sha256File(".buildchain/kfd-2/kfd-foundation.trust-assessment.json") },
+  ],
+  packageExports: [
+    { id: "export:package-json", sourcePath: "package.json#exports", sha256: sha256File("package.json") },
+    { id: "export:npm-files", sourcePath: "package.json#files", sha256: sha256File("package.json") },
+  ],
+  siteConsumptionContracts: [
+    { id: "site:kfd-site-bundle", sourcePath: "site/kfd-site.json", sha256: sha256File("site/kfd-site.json") },
+    { id: "site:release-propagation", sourcePath: "buildchain.release-propagation.json", sha256: sha256File("buildchain.release-propagation.json") },
+  ],
+};
+
+const explicitSurfaces = collaborationInterface.surfaces.map((surface) => ({
+  id: surface.id,
+  name: surface.id,
+  kind: surface.kind,
+  participantProfile: Array.isArray(surface.participants) ? surface.participants.join(",") : "",
+  availability: surface.maturity || "shipped",
+  visibility: "public",
+  participantFacing: true,
+  public: true,
+  sourcePath: surface.discoverability?.path || "",
+}));
+
+const declaredSurfaceIds = new Set(explicitSurfaces.map((surface) => surface.id));
+for (const entrypoint of collaborationInterface.minimalEntrypoints) {
+  if (declaredSurfaceIds.has(entrypoint.id)) continue;
+  explicitSurfaces.push({
+    id: entrypoint.id,
+    name: entrypoint.id,
+    kind: "entrypoint",
+    participantProfile: Array.isArray(entrypoint.participants) ? entrypoint.participants.join(",") : "",
+    availability: "shipped",
+    visibility: "public",
+    participantFacing: true,
+    public: true,
+    sourcePath: entrypoint.surface,
+  });
+  declaredSurfaceIds.add(entrypoint.id);
+}
+
+const valueEvidencePointers = (() => {
+  const entriesByPath = new Map();
+  for (const valueClaim of collaborationInterface.valueEvidence ?? []) {
+    for (const entry of [
+      ...(valueClaim.facts ?? []),
+      ...(valueClaim.evidence ?? []),
+      ...(valueClaim.trustAssessment ? [valueClaim.trustAssessment] : []),
+    ]) {
+      if (!entry?.path || entriesByPath.has(entry.path)) continue;
+      entriesByPath.set(
+        entry.path,
+        pointer(entry.path, `KFD-3 value evidence for ${valueClaim.id}: ${valueClaim.claim}`)
+      );
+    }
+  }
+  return [...entriesByPath.values()];
+})();
+
+const participantProfiles = collaborationInterface.participants.map((entry) => entry.id);
+const responsibility = {
+  registryFactsOwner: "KFD maintainers",
+  artifactVerificationOwner: "KFD package self-verification",
+  releasePassportProofOwner: "Buildchain",
+};
+const residualRisk = [
+  {
+    id: "human-language-interpretation",
+    definedBy: "https://kfd.libkungfu.dev/schemas/kfd-2/trust-taxonomy.schema.json#/$defs/residualRisk",
+    riskType: "natural-language-semantic-risk",
+    trustImpact: "downgrade-warning",
+    machineProvability: "not-exhaustively-enumerable",
+    agentAction: "semantic-review-required",
+    reason: "Natural-language standard interpretation is inspectable and reviewable but not exhaustively enumerable from package bytes.",
+    owner: "KFD maintainers",
+  },
+];
+
+const prebuild = {
+  schemaVersion: 1,
+  contract: "kungfu-buildchain-kfd-3-collaboration-interface-prebuild-witness",
+  id: "kfd-repository",
+  standard: "kfd-3",
+  supportLevel: "release",
+  source: {
+    repo: "kungfu-systems/kfd",
+  },
+  sourceRegistry: {
+    id: "kfd-collaboration-interface",
+    path: interfacePath,
+    sha256: interfaceSha,
+  },
+  collaborationInterfaceDigest: interfaceDigest,
+  collaborationInterface,
+  participantProfiles,
+  surfaces: explicitSurfaces,
+  ...groupedSurfaces,
+  auditBoundary: {
+    mode: "closed-world",
+    scope: "KFD participant-facing public collaboration/control surfaces shipped in the repository and npm package",
+    reachableSurfaceMode: "declared-boundary",
+    unclassifiedPolicy: "fail",
+    nonExhaustivelyEnumerableSurfaces: residualRisk,
+  },
+  residualRisk,
+  responsibility,
+  expectedArtifactVerification: {
+    command: "node scripts/check.mjs",
+  },
+};
+
+const artifact = {
+  schemaVersion: 1,
+  contract: "kfd-3-witness",
+  id: "kfd-repository",
+  standard: "kfd-3",
+  collaborationInterface: {
+    schemaId: standards.standards["kfd-3"].schemaIds.collaborationInterface,
+    digest: interfaceDigest,
+  },
+  sourceRegistry: {
+    id: "kfd-collaboration-interface",
+    path: interfacePath,
+    sha256: interfaceSha,
+  },
+  artifact: {
+    name: packageJson.name,
+    path: "npm:@kungfu-tech/kfd",
+    digest: interfaceDigest,
+  },
+  surfaces: explicitSurfaces,
+  ...groupedSurfaces,
+  evidence: {
+    minimalEntrypoints: collaborationInterface.minimalEntrypoints.map((entry) => pointer(entry.surface, entry.purpose)),
+    discoverability: [
+      pointer("README.md", "Human and agent entrypoint"),
+      pointer("TRADEMARKS.md", "Official status, trademark, and authority boundary"),
+      pointer("docs/MAP.md", "Documentation routing entrypoint"),
+      pointer("registry.json", "Machine-readable decision index"),
+      pointer("standards.json", "Machine-readable standards metadata"),
+      pointer(".buildchain/kfd-2/public-release-trust.claim.json", "KFD-2 public release trust claim"),
+      pointer(".buildchain/kfd-2/kfd-foundation.trust-claims.json", "KFD-2 generic trust claims for KFD self-dogfood"),
+      pointer(".buildchain/kfd-2/kfd-foundation.trust-assessment.json", "KFD-2 generic trust assessment for KFD self-dogfood"),
+      pointer("package.json", "Package export map"),
+      pointer("site/kfd-site.json", "Site content projection"),
+    ],
+    valueEvidence: valueEvidencePointers,
+    transparentConstraints: [
+      pointer("CONTRIBUTING.md", "Append-only decision and contribution constraints"),
+      pointer("TRADEMARKS.md", "Trademark and official-status constraints"),
+      pointer("scripts/check.mjs", "Repository self-verification gate"),
+      pointer("site/kfd-site.json", "Site rendering boundary"),
+    ],
+    choicePaths: [
+      pointer("README.md", "Human reading path"),
+      pointer("registry.json", "Agent registry path"),
+      pointer("standards.json", "Agent standards metadata path"),
+      pointer(".buildchain/kfd-2/public-release-trust.claim.json", "Agent release trust claim path"),
+      pointer(".buildchain/kfd-2/kfd-foundation.trust-claims.json", "Agent generic trust claims path"),
+      pointer(".buildchain/kfd-2/kfd-foundation.trust-assessment.json", "Agent generic trust assessment path"),
+      pointer("package.json", "Package consumption path"),
+    ],
+    manuals: [
+      pointer("docs/MAP.md"),
+      pointer("TRADEMARKS.md"),
+      pointer("docs/KFD-1-usage.md"),
+      pointer("docs/KFD-2-usage.md"),
+      pointer("docs/KFD-3-usage.md"),
+      pointer("docs/KFD-4-usage.md"),
+    ],
+  },
+  closure: {
+    classificationMode: "closed-world",
+    reachableEntrypoints: collaborationInterface.minimalEntrypoints.map((entry) => entry.id),
+    classifiedEntrypoints: collaborationInterface.minimalEntrypoints.map((entry) => entry.id),
+    unclassifiedEntrypoints: [],
+  },
+  verifier: {
+    name: "kfd self-verification",
+    command: "node scripts/check.mjs",
+  },
+  residualRisk,
+  result: "pass",
+};
+
+writeJson(prebuildPath, prebuild);
+writeJson(artifactPath, artifact);
+console.log(`updated ${prebuildPath}`);
+console.log(`updated ${artifactPath}`);

package/scripts/update-site-bundle.mjs

@@ -0,0 +1,353 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+const README_PATH = "README.md";
+const REGISTRY_PATH = "registry.json";
+const SITE_BUNDLE_PATH = "site/kfd-site.json";
+
+const normalizeLines = (value) => String(value || "").replace(/\r\n/g, "\n").trim();
+
+const paragraphBlocks = (markdown) => normalizeLines(markdown)
+  .split(/\n{2,}/)
+  .map((block) => block.replace(/\n/g, " ").trim())
+  .filter(Boolean);
+
+const stripInlineCode = (value) => String(value || "").replace(/`([^`]+)`/g, "$1");
+
+const parseReadme = (markdown) => {
+  const content = normalizeLines(markdown);
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (!titleMatch) throw new Error("README.md must start with an H1 title");
+
+  const sections = {};
+  const headingPattern = /^##\s+(.+)$/gm;
+  const headings = [];
+  let match;
+  while ((match = headingPattern.exec(content))) {
+    headings.push({ title: match[1], index: match.index, bodyStart: headingPattern.lastIndex });
+  }
+  for (let index = 0; index < headings.length; index += 1) {
+    const current = headings[index];
+    const next = headings[index + 1];
+    sections[current.title] = content.slice(current.bodyStart, next ? next.index : content.length).trim();
+  }
+
+  const intro = content.slice(titleMatch[0].length, headings[0]?.index ?? content.length).trim();
+  return {
+    title: titleMatch[1].trim(),
+    intro,
+    sections,
+  };
+};
+
+const introLead = (intro) => {
+  const blocks = paragraphBlocks(intro);
+  return {
+    lead: blocks[0] || "",
+    decisionKinds: blocks.find((block) => block.startsWith("KFDs can be ")) || "",
+  };
+};
+
+const parseFoundationTriad = (markdown) => {
+  const code = markdown.match(/```text\n([\s\S]*?)\n```/);
+  if (!code) throw new Error("Foundation triad must include a text code block");
+  const before = markdown.slice(0, code.index).trim();
+  const after = markdown.slice((code.index ?? 0) + code[0].length).trim();
+  const commitments = code[1].split("\n").map((line) => {
+    const item = line.match(/^(KFD-[0-9]+):\s+(.+)$/);
+    if (!item) throw new Error(`invalid foundation triad line: ${line}`);
+    return { id: item[1], text: item[2] };
+  });
+  return {
+    heading: "Foundation triad",
+    intro: paragraphBlocks(before)[0] || "",
+    commitments,
+    summary: paragraphBlocks(after)[0] || "",
+  };
+};
+
+const parseMarkdownTable = (markdown) => {
+  const rows = markdown.split("\n").filter((line) => line.trim().startsWith("|"));
+  if (rows.length < 3) return [];
+  return rows.slice(2).map((row) => row.trim().replace(/^\||\|$/g, "").split("|").map((cell) => stripInlineCode(cell.trim())))
+    .filter((cells) => cells.length >= 4)
+    .map(([layer, decision, readerQuestion, commitment]) => ({
+      layer,
+      decision,
+      readerQuestion,
+      commitment,
+    }));
+};
+
+const parseFoundationModel = (markdown) => {
+  const chainMatch = markdown.match(/```text\n([\s\S]*?)\n```/);
+  if (!chainMatch) throw new Error("Foundation model must include the chain text code block");
+  const beforeChain = markdown.slice(0, chainMatch.index).trim();
+  const afterChain = markdown.slice((chainMatch.index ?? 0) + chainMatch[0].length).trim();
+  return {
+    heading: "Foundation model",
+    intro: paragraphBlocks(beforeChain)[0] || "",
+    layers: parseMarkdownTable(beforeChain),
+    chain: chainMatch[1].trim(),
+    explanation: paragraphBlocks(afterChain),
+  };
+};
+
+const parsePracticeGuidelines = (markdown) => ({
+  heading: "Practice guidelines",
+  intro: paragraphBlocks(markdown)[0] || "",
+  guidelines: parseMarkdownTable(markdown),
+  explanation: paragraphBlocks(markdown).slice(1),
+});
+
+const parseProductProofPath = (markdown) => ({
+  heading: "Product proof path",
+  body: paragraphBlocks(markdown)[0] || "",
+});
+
+const usagePathForEntry = (entry) => `docs/KFD-${entry.number}-usage.md`;
+const usageUrlForEntry = (entry) => `${entry.url}/usage`;
+
+const buildUsagePages = (entries) => entries.map((entry) => {
+  const usagePath = usagePathForEntry(entry);
+  return {
+    id: `${entry.id}-usage`,
+    decisionId: entry.id,
+    decisionNumber: entry.number,
+    parentPath: entry.path,
+    parentUrl: entry.url,
+    path: usagePath,
+    url: usageUrlForEntry(entry),
+    sourcePath: usagePath,
+    sourceExists: existsSync(usagePath),
+    relationship: "usage-child-of-decision",
+    title: `${entry.id} usage`,
+  };
+});
+
+const section = ({ id, sourceHeading, title, markdown, role, priority, presentation, firstScreen = false }) => ({
+  id,
+  sourcePath: README_PATH,
+  sourceHeading,
+  title,
+  renderRole: role,
+  homepagePriority: priority,
+  defaultPresentation: presentation,
+  includeInFirstScreen: firstScreen,
+  markdown: normalizeLines(markdown),
+});
+
+export const buildSiteBundle = ({ readmeText, registry }) => {
+  const readme = parseReadme(readmeText);
+  const { lead, decisionKinds } = introLead(readme.intro);
+  const foundationTriad = parseFoundationTriad(readme.sections["Foundation triad"] || "");
+  const foundationModel = parseFoundationModel(readme.sections["Foundation model"] || "");
+  const practiceGuidelines = parsePracticeGuidelines(readme.sections["Practice guidelines"] || "");
+  const productProofPath = parseProductProofPath(readme.sections["Product proof path"] || "");
+  const entries = registry.entries || [];
+
+  const homepageSections = [
+    section({
+      id: "foundation-triad",
+      sourceHeading: "Foundation triad",
+      title: "Foundation triad",
+      markdown: readme.sections["Foundation triad"],
+      role: "first-screen",
+      priority: 10,
+      presentation: "triad-cards",
+      firstScreen: true,
+    }),
+    section({
+      id: "foundation-model",
+      sourceHeading: "Foundation model",
+      title: "Foundation model",
+      markdown: readme.sections["Foundation model"],
+      role: "primary",
+      priority: 20,
+      presentation: "layered-model",
+      firstScreen: true,
+    }),
+    section({
+      id: "adoption-boundary",
+      sourceHeading: "Adoption boundary",
+      title: "Adoption boundary",
+      markdown: readme.sections["Adoption boundary"],
+      role: "primary",
+      priority: 25,
+      presentation: "boundary-note",
+    }),
+    section({
+      id: "practice-guidelines",
+      sourceHeading: "Practice guidelines",
+      title: "Practice guidelines",
+      markdown: readme.sections["Practice guidelines"],
+      role: "primary",
+      priority: 27,
+      presentation: "practice-table",
+    }),
+    section({
+      id: "product-proof-path",
+      sourceHeading: "Product proof path",
+      title: "Product proof path",
+      markdown: readme.sections["Product proof path"],
+      role: "primary",
+      priority: 30,
+      presentation: "proof-path",
+    }),
+    section({
+      id: "agent-quickstart",
+      sourceHeading: "Agent Quickstart",
+      title: "Agent Quickstart",
+      markdown: readme.sections["Agent Quickstart"],
+      role: "support",
+      priority: 40,
+      presentation: "ordered-steps",
+    }),
+    section({
+      id: "decision-metadata",
+      sourceHeading: "Decision metadata",
+      title: "Decision metadata",
+      markdown: readme.sections["Decision metadata"],
+      role: "support",
+      priority: 50,
+      presentation: "fact-source",
+    }),
+  ];
+
+  return {
+    schemaVersion: 1,
+    contract: "kfd-site-bundle",
+    source: {
+      package: "@kungfu-tech/kfd",
+      homepageTextSource: README_PATH,
+      registry: REGISTRY_PATH,
+      decisionsDir: "decisions",
+    },
+    routes: {
+      home: "/",
+      decisionPattern: "/{number}",
+      decisionUsagePattern: "/{number}/usage",
+      llms: "/llms.txt",
+      manifest: "/manifest.json",
+    },
+    homepage: {
+      title: readme.title,
+      lead,
+      decisionKinds,
+      foundationTriad,
+      foundationModel,
+      practiceGuidelines,
+      productProofPath,
+      currentDecisions: {
+        heading: "Current decisions",
+        source: REGISTRY_PATH,
+      },
+      sections: homepageSections,
+      displayPlan: {
+        firstScreen: {
+          include: ["title", "lead", "foundation-triad", "foundation-model.chain"],
+          maxPrimarySections: 2,
+          note: "The first viewport should establish KFD identity and the three-decision worldview without showing renderer or developer contract text.",
+        },
+        primary: ["foundation-triad", "foundation-model", "adoption-boundary", "practice-guidelines", "product-proof-path"],
+        support: ["agent-quickstart", "decision-metadata"],
+        currentDecisions: {
+          source: REGISTRY_PATH,
+          placement: "after-primary",
+          ids: entries.map((entry) => entry.id),
+        },
+      },
+      rendererContract: {
+        ...section({
+          id: "homepage-content-contract",
+          sourceHeading: "Homepage content contract",
+          title: "Homepage content contract",
+          markdown: readme.sections["Homepage content contract"],
+          role: "renderer-contract",
+          priority: 90,
+          presentation: "developer-note",
+        }),
+        renderAsHomepageContent: false,
+        note: "This is a machine/renderer contract for site implementers. It should not be rendered as ordinary homepage content.",
+      },
+    },
+    decisionPages: {
+      source: REGISTRY_PATH,
+      bodySource: "registry.entries[].path",
+      stableUrlField: "url",
+      usagePages: {
+        source: "registry.entries[] + docs/KFD-N-usage.md",
+        bodySource: "docs/KFD-{number}-usage.md",
+        stableUrlPattern: "/{number}/usage",
+        relationship: "usage-child-of-decision",
+        pages: buildUsagePages(entries),
+      },
+      metadata: {
+        licenseBoundary: {
+          license: "Apache-2.0",
+          licenseFile: "LICENSE",
+          officialStatusAndTrademarks: "TRADEMARKS.md",
+          summary: "Apache-2.0 covers repository contents; it does not grant KFD/Kungfu trademarks, official status, certification status, or endorsement.",
+        },
+        publicFactSource: {
+          kind: "git-repository",
+          host: "github",
+          repository: "kungfu-systems/kfd",
+          url: "https://github.com/kungfu-systems/kfd",
+          loadBearingCoordinate: "commit-addressed repository contents",
+          stableRenderedIndex: "https://kfd.libkungfu.dev",
+          canonicalPaths: [
+            "decisions/KFD-N.md",
+            REGISTRY_PATH,
+            "standards.json",
+          ],
+          projectionSurfaces: [
+            "https://kfd.libkungfu.dev/N",
+            "npm:@kungfu-tech/kfd",
+            "Buildchain release passports",
+          ],
+          extensionRequestNote: "GitHub issues are extension request paths; KFD facts are created only by committed repository contents.",
+        },
+      },
+    },
+    renderingBoundary: {
+      ownedByKfd: [
+        "homepage title and text",
+        "homepage section projection from README.md",
+        "foundation triad commitments",
+        "foundation model layers and chain",
+        "product proof path text",
+        "agent quickstart text",
+        "decision metadata",
+        "decision metadata fact source",
+        "license and official-status boundary",
+        "decision markdown bodies",
+        "decision usage page mapping",
+        "decision usage markdown bodies",
+      ],
+      ownedBySite: [
+        "HTML structure",
+        "CSS",
+        "responsive layout",
+        "navigation layout",
+        "visual assets",
+        "decorative images",
+        "markdown-to-HTML renderer",
+        "section presentation and progressive disclosure within KFD displayPlan constraints",
+      ],
+    },
+  };
+};
+
+export const readInputs = () => ({
+  readmeText: readFileSync(README_PATH, "utf8"),
+  registry: JSON.parse(readFileSync(REGISTRY_PATH, "utf8")),
+});
+
+export const generatedSiteBundle = () => buildSiteBundle(readInputs());
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const bundle = generatedSiteBundle();
+  writeFileSync(SITE_BUNDLE_PATH, `${JSON.stringify(bundle, null, 2)}\n`);
+  console.log(`updated ${SITE_BUNDLE_PATH}`);
+}