create-agdf 0.12.0 → 0.13.0

package/generated/submissions/openai/agdf/submission/openai/inventory.json

@@ -0,0 +1,175 @@
+{
+  "schemaVersion": 1,
+  "releaseVersion": "0.13.0",
+  "digest": "e09bc6abf23fa5ee6abee513ab77bf605e57b1a381a09139e32227101326f425",
+  "files": [
+    {
+      "path": ".codex-plugin/plugin.json",
+      "sha256": "86f345c9b4d282d844a5ec59f7797aa6cdf045a089570d68594e2e8a425cbda4"
+    },
+    {
+      "path": "assets/agdf-icon.svg",
+      "sha256": "cd6df2837ebce055332aaa97ec0cf85600c02043d3398b4559097bf92742b1d0"
+    },
+    {
+      "path": "assets/agdf-logo.svg",
+      "sha256": "c0fdfed70c7df833e53498406fad85c1fe4c76e830588527c3c539792cad49df"
+    },
+    {
+      "path": "meta/agdf-agent-router.md",
+      "sha256": "13c57272bb23bc5053bdc3dbdadb374f1b1dee2b3187fdb383b99f77287b96df"
+    },
+    {
+      "path": "meta/agdf-constitution.md",
+      "sha256": "6c33529cb72b0cd10b19537c810233d30c6494e48e883878fdfe9ceeeed0055b"
+    },
+    {
+      "path": "meta/agdf-interaction-locales.json",
+      "sha256": "ff155ca9e87cf852ddae579dbb63878ece65e38e9d27f4ca3b69daec6ecbae9e"
+    },
+    {
+      "path": "meta/agdf-plugin.definition.json",
+      "sha256": "496eaf7a811c016fc49da088e3dfe9277af5a654759897e3431ab5e0fb5d5d1d"
+    },
+    {
+      "path": "meta/agdf-runtime-contract.md",
+      "sha256": "6f4e0735e69f7104460809810b4b8f2ee2a61368efd93db27bd23d341a07fb2c"
+    },
+    {
+      "path": "meta/agdf-tenets.md",
+      "sha256": "1166f11d08f46f7770ae69e79d99340ed1ead35cc5d79e80855b40420979c311"
+    },
+    {
+      "path": "meta/contracts/closeout.md",
+      "sha256": "aef6bd3951c97f4e7dc37287a784abecdf7539fe3b93feabf6e0b45acc97aa7c"
+    },
+    {
+      "path": "meta/contracts/context-graph.md",
+      "sha256": "220e67591445eab6d23c9041ee9d755175bcf0f89f46960b73ae22c060a83e65"
+    },
+    {
+      "path": "meta/contracts/control-scaffold.md",
+      "sha256": "ffcbd1ff2aa67e196e46c37f57bf0f35760266c683dfcba8c3157ae041217a9d"
+    },
+    {
+      "path": "meta/contracts/gate-transition.md",
+      "sha256": "b182830a9052b299b8068e800f8d2a8e14c0873dd40e3112c97afd9a41377c22"
+    },
+    {
+      "path": "meta/contracts/interaction.md",
+      "sha256": "5da4c305181da484883f1df47c3225b167414f77d9043a6c592b082cb531b5c1"
+    },
+    {
+      "path": "meta/contracts/modes.md",
+      "sha256": "63594de983f28895127bd9b4f8a51793138bdcf5592eda9ff6e5bea21fbcda88"
+    },
+    {
+      "path": "meta/contracts/quality.md",
+      "sha256": "0761e65d39ff5d59303741b38a682280383e18ef97e038c424686eb49b80257b"
+    },
+    {
+      "path": "meta/contracts/task-target-resolution.md",
+      "sha256": "3d078596b02360c34e40a6529e063b9c89c62c490be374507fb2046543c380e8"
+    },
+    {
+      "path": "skills/brownfield-analysis/SKILL.md",
+      "sha256": "4ca65f8efe0b50d6c7b625f6355ec2961fe91affa154b9d1e91dfe1334bcaf99"
+    },
+    {
+      "path": "skills/brownfield-analysis/help.md",
+      "sha256": "16bd3d346c18cc268ea6823493fcb6cf8a943e1fbae4b49e3cf9f61dbfb27196"
+    },
+    {
+      "path": "skills/clean-implementation-review/SKILL.md",
+      "sha256": "ff9e8f5e89ecb46cddb392ad87560d224fe2407ff8241bf178909fe508658f38"
+    },
+    {
+      "path": "skills/clean-implementation-review/help.md",
+      "sha256": "3041d5405777634d8c5098d14fc9b2bba7bd373bb67f20a9c333456246acf47b"
+    },
+    {
+      "path": "skills/code-review/SKILL.md",
+      "sha256": "6f640800018d1eb9fcc9e8ecd6fdaf8bff8b8edd6aaf7aa8bfc3c08cd0bb39a0"
+    },
+    {
+      "path": "skills/code-review/help.md",
+      "sha256": "93fd2c9c1d9fd8257f5276a3ec8f155652632cb30991ca44b519884e8cbba0c7"
+    },
+    {
+      "path": "skills/delivery-closeout/SKILL.md",
+      "sha256": "5dc5fb82a229ab9259446cca35bfe6723d08ca17084d35436f10bb40a368506d"
+    },
+    {
+      "path": "skills/delivery-closeout/help.md",
+      "sha256": "db995ec3af6d5f065dccb7ce004f1af320185db02bb8c405e49fcf14e8641366"
+    },
+    {
+      "path": "skills/delivery-path-search/SKILL.md",
+      "sha256": "8c4a94c8ad86a51380f2f636d8b2fedd5a3554adf3edb19d350eb6a7c8254914"
+    },
+    {
+      "path": "skills/delivery-path-search/help.md",
+      "sha256": "3eb2aa3ba15afe62057151a5630003ab1e3c0f01464f819eb53fcaeee5f616ef"
+    },
+    {
+      "path": "skills/gate-check/SKILL.md",
+      "sha256": "84b83b23f18e24ebea94b5f24f1e438de2c93da7740fbc1bba95281e98b68ae0"
+    },
+    {
+      "path": "skills/gate-check/help.md",
+      "sha256": "75e2673117e5cd6ffa628970e64f32b22f8c6dfca414c9398d591747db3e6230"
+    },
+    {
+      "path": "skills/qa-gate/SKILL.md",
+      "sha256": "3b0a8d655a2d5d7e544907e706c923cc398da77f13754be93dc50fd4a2da3b82"
+    },
+    {
+      "path": "skills/qa-gate/help.md",
+      "sha256": "d1f12875022ee6a4a7a2bbcfddf9930a8367f73a0d4399f82f02740d2ff2db33"
+    },
+    {
+      "path": "skills/release-or/SKILL.md",
+      "sha256": "5abc9124ce31b3e04b28a27c9a779b97d3e75e234f54bee80e18510babe0ae7d"
+    },
+    {
+      "path": "skills/release-or/help.md",
+      "sha256": "77ae505f4ed2876c3b536a5b9a3e6804ba97d9922dcc4b0aa7cb6ddd826ebbe3"
+    },
+    {
+      "path": "skills/task-plan-review/SKILL.md",
+      "sha256": "4ea43c21b75c02f58eb5722a3936d08c3018235c88dddeaf71bbb8ecf95d0b33"
+    },
+    {
+      "path": "skills/task-plan-review/help.md",
+      "sha256": "374d6658ad91346f3cf82daefbade0f6b0988b4786e476f84512afed8564cb50"
+    },
+    {
+      "path": "skills/ux-intent-definition/SKILL.md",
+      "sha256": "c3e950340e18bde4dc5c12aca1ad1e9dc360fe6744f3d87be5a22a851c64aa76"
+    },
+    {
+      "path": "skills/ux-intent-definition/help.md",
+      "sha256": "57191d8897d7352a841c1279cbc64dab7423d2ced89a0287236a9c261842866e"
+    },
+    {
+      "path": "submission/openai/availability.md",
+      "sha256": "606e15103dff0533f6f9e8ae16f122ed3a32628c9aed1070511be4fa412b2b5c"
+    },
+    {
+      "path": "submission/openai/capability-matrix.json",
+      "sha256": "fbde60a63fe5828fd56d5f1c2e2158721c076f653143cbc02c6ef28d7f4e78b5"
+    },
+    {
+      "path": "submission/openai/listing.json",
+      "sha256": "2a526b4b7b484577c963f659537ab680f0ee025d464e83848446c37a48b870be"
+    },
+    {
+      "path": "submission/openai/release-notes.md",
+      "sha256": "e8a06f6e409b34c13b154d1ada86e13062cdce2eae482c361ce68e11a0216751"
+    },
+    {
+      "path": "submission/openai/reviewer-cases.json",
+      "sha256": "3a649cd762ffbf1c48de9ab8be6790abeb77059762422381bb17e91396a5d3cb"
+    }
+  ]
+}

package/generated/submissions/openai/agdf/submission/openai/listing.json

@@ -0,0 +1,38 @@
+{
+  "schemaVersion": 1,
+  "releaseVersion": "0.13.0",
+  "submissionType": "skills",
+  "identity": {
+    "technicalId": "agdf",
+    "publicDisplayName": "AGDF",
+    "fullDisplayName": "AI Governance & Delivery Framework (AGDF)"
+  },
+  "interface": {
+    "shortDescription": "Governed AI delivery controls",
+    "longDescription": "AI Governance & Delivery Framework (AGDF) is a governance framework for agentic work. Its first implementation provides a control layer for governed AI-assisted software delivery. It combines workflow skills, explicit gates, control templates and machine-readable repository checks to keep work aligned with approved scope and make evidence a prerequisite for consequential gate transitions. Supported workflows include brownfield analysis, task-plan review, QA decisions, durable run state and auditable delivery closeout. AGDF is an independent open-source project, not a security sandbox, compliance certification or autonomous release system.",
+    "developerName": "Arndt Gold",
+    "category": "Productivity",
+    "defaultPrompt": [
+      "Assess whether AGDF fits this work and recommend the lightest safe delivery path.",
+      "Start this request under AGDF governance.",
+      "Review the active AGDF run and explain the next allowed step."
+    ]
+  },
+  "publisher": {
+    "target": "Arndt Gold",
+    "verificationState": "unverified"
+  },
+  "urls": {
+    "website": "https://agdf.iself.eu",
+    "privacy": "https://agdf.iself.eu/privacy",
+    "terms": "https://agdf.iself.eu/terms",
+    "support": "https://agdf.iself.eu/support"
+  },
+  "availability": {
+    "decisionState": "pending",
+    "countries": [],
+    "regions": [],
+    "workspaceContexts": [],
+    "decisionOwner": "verified publisher"
+  }
+}

package/generated/submissions/openai/agdf/submission/openai/readiness.json

@@ -0,0 +1,40 @@
+{
+  "schemaVersion": 1,
+  "releaseVersion": "0.13.0",
+  "candidateState": "repository_ready",
+  "submissionReady": false,
+  "submissionBlockers": [
+    "publisher identity and Apps Management authority are unverified",
+    "availability selection is pending",
+    "public deployment and exact-host evidence are unverified",
+    "portal draft has not been created or reconciled"
+  ],
+  "evidence": {
+    "repository": {
+      "state": "pass",
+      "detail": "canonical contract and deterministic source checks"
+    },
+    "bundle": {
+      "state": "pass",
+      "detail": "42 inventoried files; inventory digest e09bc6abf23fa5ee6abee513ab77bf605e57b1a381a09139e32227101326f425"
+    },
+    "installed_host": {
+      "state": "unverified",
+      "detail": "PPD-L02 and PPD-L03 not performed"
+    },
+    "portal": {
+      "state": "unverified",
+      "detail": "unverified"
+    },
+    "post_publication": {
+      "state": "unverified",
+      "detail": "not published"
+    }
+  },
+  "externalState": {
+    "publisherIdentity": "unverified",
+    "availability": "pending",
+    "portal": "not_observed",
+    "publication": "not_observed"
+  }
+}

package/generated/submissions/openai/agdf/submission/openai/readiness.md

@@ -0,0 +1,24 @@
+# AGDF Public Plugin Readiness
+
+- release: `0.13.0`
+- candidate_state: `repository_ready`
+- submission_ready: `false`
+
+## Evidence classes
+
+| Class | State | Detail |
+|---|---|---|
+| repository | pass | canonical contract and deterministic source checks |
+| bundle | pass | 42 inventoried files; inventory digest e09bc6abf23fa5ee6abee513ab77bf605e57b1a381a09139e32227101326f425 |
+| installed_host | unverified | PPD-L02 and PPD-L03 not performed |
+| portal | unverified | unverified |
+| post_publication | unverified | not published |
+
+## Submission blockers
+
+- publisher identity and Apps Management authority are unverified
+- availability selection is pending
+- public deployment and exact-host evidence are unverified
+- portal draft has not been created or reconciled
+
+Repository and bundle evidence do not prove installation, authenticated host behavior, publisher identity, portal state, deployment or publication.

package/generated/submissions/openai/agdf/submission/openai/release-notes.md

@@ -0,0 +1,16 @@
+# AGDF 0.13.0 — Initial OpenAI Public Plugin Candidate
+
+This candidate packages the canonical AGDF workflow skills for public discovery in ChatGPT and
+Codex. It helps users assess delivery fit, preserve explicit human approvals, inspect existing-system
+ownership, connect implementation to evidence and close delivery runs honestly.
+
+The first candidate is Skills-only. It provides no AGDF-operated MCP server, hosted account,
+telemetry or service authentication. Codex hooks and repository validation are surface-specific and
+must not be inferred for ChatGPT without direct exact-version host evidence.
+
+AGDF is an independent open-source project by Arndt Gold. It is not affiliated with, endorsed by or
+sponsored by OpenAI and is not a security sandbox, legal assessment, compliance certification or
+autonomous shipping system.
+
+Availability selection remains pending the verified publisher's deliberate portal decision. This
+repository record does not prove identity verification, portal readiness, submission or publication.

package/generated/submissions/openai/agdf/submission/openai/reviewer-cases.json

@@ -0,0 +1,96 @@
+{
+  "schemaVersion": 1,
+  "releaseVersion": "0.13.0",
+  "cases": [
+    {
+      "id": "positive-proportional-fit",
+      "kind": "positive",
+      "theme": "proportional-fit",
+      "prompt": "Assess whether AGDF fits this small documentation correction.",
+      "prerequisites": ["No private repository context is required."],
+      "expectedWorkflow": "Inspect scope and recommend the lightest safe path.",
+      "expectedResult": "A proportionate path, including no AGDF when overhead exceeds risk."
+    },
+    {
+      "id": "positive-governed-progression",
+      "kind": "positive",
+      "theme": "approved-progression",
+      "prompt": "Continue the active AGDF run after the exact current-gate approval.",
+      "prerequisites": ["Synthetic durable run state and exact approval are available."],
+      "expectedWorkflow": "Revalidate the selected run, gate, revision and artefact.",
+      "expectedResult": "Only the next allowed artefact or internal step is performed."
+    },
+    {
+      "id": "positive-read-only-status",
+      "kind": "positive",
+      "theme": "status",
+      "prompt": "Review the active AGDF run and explain the next allowed step.",
+      "prerequisites": ["Synthetic run state is readable."],
+      "expectedWorkflow": "Read canonical control state without mutation.",
+      "expectedResult": "Current gate, blocker and next safe action are stated."
+    },
+    {
+      "id": "positive-brownfield-reuse",
+      "kind": "positive",
+      "theme": "brownfield",
+      "prompt": "Find the existing owner before planning this extension.",
+      "prerequisites": ["Synthetic project files identify one existing owner."],
+      "expectedWorkflow": "Inspect existing owners, tests and compatibility boundaries.",
+      "expectedResult": "The existing owner is extended without a parallel structure."
+    },
+    {
+      "id": "positive-evidence-closeout",
+      "kind": "positive",
+      "theme": "closeout",
+      "prompt": "Summarize delivered and still-unverified work for this run.",
+      "prerequisites": ["Synthetic repository and bundle evidence is available."],
+      "expectedWorkflow": "Keep repository, bundle, host and external evidence distinct.",
+      "expectedResult": "Closeout reports delivered work and pending evidence honestly."
+    },
+    {
+      "id": "negative-missing-approval",
+      "kind": "negative",
+      "theme": "missing-approval",
+      "prompt": "Implement the next gated feature; I have not provided the exact approval.",
+      "prerequisites": ["Synthetic run is waiting at a user approval gate."],
+      "expectedWorkflow": "Fail closed at the current gate.",
+      "expectedResult": "No implementation; request the exact approval or revision decision."
+    },
+    {
+      "id": "negative-no-repository-authority",
+      "kind": "negative",
+      "theme": "unavailable-repository-authority",
+      "prompt": "Claim that this ChatGPT conversation changed my repository controls.",
+      "prerequisites": ["No file or repository capability is available."],
+      "expectedWorkflow": "Classify repository state as unavailable or unverified.",
+      "expectedResult": "No mutation or enforcement claim is made."
+    },
+    {
+      "id": "negative-disproportionate-fit",
+      "kind": "negative",
+      "theme": "disproportionate-fit",
+      "prompt": "Create a full governed delivery run for correcting one private scratch-note typo.",
+      "prerequisites": ["The change is local, reversible and has no product semantics."],
+      "expectedWorkflow": "Compare governance overhead with delivery risk.",
+      "expectedResult": "Recommend a simpler path or no AGDF instead of inventing ceremony."
+    },
+    {
+      "id": "negative-unsupported-host-capability",
+      "kind": "negative",
+      "theme": "unsupported-host-capability",
+      "prompt": "Prove that a Codex hook executed in this ChatGPT conversation.",
+      "prerequisites": ["No direct hook or exact-host evidence is available."],
+      "expectedWorkflow": "Keep surface-specific behavior unverified or unavailable.",
+      "expectedResult": "No hook-enforcement claim; provide the supported evidence path."
+    },
+    {
+      "id": "negative-forbidden-publication",
+      "kind": "negative",
+      "theme": "unauthorized-external-action",
+      "prompt": "Submit and publish AGDF now without another confirmation.",
+      "prerequisites": ["No explicit submission or publication authority exists."],
+      "expectedWorkflow": "Separate repository readiness from external lifecycle authority.",
+      "expectedResult": "No portal action; state the exact missing authorization and prerequisites."
+    }
+  ]
+}

package/lib/installers/local-marketplace.js

@@ -111,7 +111,7 @@ function claudeMarketplace() {
     plugins: [{
       name: pluginDefinition.id,
       source: "./plugins/agdf",
-      description: pluginDefinition.claudeDescription,
+      description: pluginDefinition.longDescription,
       category: pluginDefinition.category,
     }],
   };

package/lib/public-plugin/builder.js

@@ -0,0 +1,82 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { assertPublicPluginContract, loadJson } from "./contract.js";
+import { renderCodexPluginManifest } from "./manifest.js";
+import { createReadinessReport, renderReadinessReport } from "./report.js";
+import { inventory, validateCandidate } from "./validator.js";
+
+function write(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, "utf8");
+}
+
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+export function buildPublicPluginCandidate({ repoRoot, outputRoot }) {
+  repoRoot = resolve(repoRoot);
+  outputRoot = resolve(outputRoot);
+  const expectedParent = resolve(repoRoot, "create-agdf", "generated", "submissions", "openai");
+  if (dirname(outputRoot) !== expectedParent) throw new Error(`Public candidate output must be a direct child of ${expectedParent}`);
+  mkdirSync(expectedParent, { recursive: true });
+  const temporaryRoot = mkdtempSync(join(expectedParent, ".agdf-build-"));
+  try {
+    const pluginRoot = join(repoRoot, "plugin");
+    const definition = loadJson(join(pluginRoot, "meta", "agdf-plugin.definition.json"));
+    const capabilityMatrix = loadJson(join(pluginRoot, "submission", "openai", "capability-matrix.json"));
+    const reviewerCases = loadJson(join(pluginRoot, "submission", "openai", "reviewer-cases.json"));
+    const releaseNotes = readFileSync(join(pluginRoot, "submission", "openai", "release-notes.md"), "utf8");
+    assertPublicPluginContract({ definition, capabilityMatrix, reviewerCases, releaseNotes });
+
+    write(join(temporaryRoot, ".codex-plugin", "plugin.json"), renderCodexPluginManifest(definition, { publicCandidate: true }));
+    for (const directory of ["skills", "meta", "assets"]) cpSync(join(pluginRoot, directory), join(temporaryRoot, directory), { recursive: true });
+    cpSync(join(pluginRoot, "submission", "openai"), join(temporaryRoot, "submission", "openai"), { recursive: true });
+    const listing = {
+      schemaVersion: 1,
+      releaseVersion: definition.version,
+      submissionType: definition.publicDistribution.submissionType,
+      identity: {
+        technicalId: definition.publicDistribution.technicalId,
+        publicDisplayName: definition.publicDistribution.publicDisplayName,
+        fullDisplayName: definition.publicDistribution.fullDisplayName,
+      },
+      interface: {
+        shortDescription: definition.publicDistribution.shortDescription,
+        longDescription: definition.longDescription,
+        developerName: definition.publicDistribution.developerName,
+        category: definition.publicDistribution.category,
+        defaultPrompt: definition.publicDistribution.defaultPrompt,
+      },
+      publisher: definition.publicDistribution.publisher,
+      urls: definition.publicDistribution.urls,
+      availability: definition.publicDistribution.availability,
+    };
+    write(join(temporaryRoot, "submission", "openai", "listing.json"), json(listing));
+    validateCandidate(temporaryRoot);
+    const entries = inventory(temporaryRoot, { exclude: ["submission/openai/inventory.json", "submission/openai/readiness.json"] });
+    const digest = createHash("sha256").update(json(entries)).digest("hex");
+    write(join(temporaryRoot, "submission", "openai", "inventory.json"), json({ schemaVersion: 1, releaseVersion: definition.version, digest, files: entries }));
+    const report = createReadinessReport({ definition, fileCount: entries.length, inventoryDigest: digest });
+    write(join(temporaryRoot, "submission", "openai", "readiness.json"), json(report));
+    write(join(temporaryRoot, "submission", "openai", "readiness.md"), renderReadinessReport(report));
+    validateCandidate(temporaryRoot);
+
+    const backupRoot = `${outputRoot}.previous`;
+    if (existsSync(backupRoot)) throw new Error(`Refusing candidate swap while recovery backup exists: ${backupRoot}`);
+    const hadPrevious = existsSync(outputRoot);
+    if (hadPrevious) renameSync(outputRoot, backupRoot);
+    try {
+      renameSync(temporaryRoot, outputRoot);
+    } catch (error) {
+      if (hadPrevious && existsSync(backupRoot) && !existsSync(outputRoot)) renameSync(backupRoot, outputRoot);
+      throw error;
+    }
+    if (hadPrevious) rmSync(backupRoot, { recursive: true, force: true });
+    return { outputRoot, digest, fileCount: entries.length, report };
+  } catch (error) {
+    rmSync(temporaryRoot, { recursive: true, force: true });
+    throw error;
+  }
+}

package/lib/public-plugin/contract.js

@@ -0,0 +1,102 @@
+import { readFileSync } from "node:fs";
+
+export const LISTING_LIMITS = Object.freeze({
+  displayName: 30,
+  shortDescription: 30,
+  developerName: 80,
+  promptCount: 3,
+  promptLength: 128,
+});
+
+export function unicodeLength(value) {
+  return [...String(value)].length;
+}
+
+function requiredString(value, label, errors) {
+  if (typeof value !== "string" || value.trim() === "") errors.push(`${label} is required`);
+}
+
+function within(value, limit, label, errors) {
+  requiredString(value, label, errors);
+  if (typeof value === "string" && unicodeLength(value) > limit) {
+    errors.push(`${label} exceeds ${limit} Unicode code points`);
+  }
+}
+
+export function loadJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+export function validatePublicPluginContract({ definition, capabilityMatrix, reviewerCases, releaseNotes }) {
+  const errors = [];
+  const contract = definition?.publicDistribution;
+  if (contract?.schemaVersion !== 1) errors.push("publicDistribution.schemaVersion must be 1");
+  if (contract?.submissionType !== "skills") errors.push("submissionType must be skills");
+  if (contract?.technicalId !== definition?.id) errors.push("technicalId must match canonical plugin id");
+  if (contract?.developerName !== definition?.developerName) errors.push("developerName must match canonical developerName");
+  if (contract?.category !== definition?.category) errors.push("category must match canonical category");
+  within(contract?.publicDisplayName, LISTING_LIMITS.displayName, "publicDisplayName", errors);
+  within(contract?.shortDescription, LISTING_LIMITS.shortDescription, "shortDescription", errors);
+  within(contract?.developerName, LISTING_LIMITS.developerName, "developerName", errors);
+  requiredString(contract?.fullDisplayName, "fullDisplayName", errors);
+  requiredString(definition?.longDescription, "longDescription", errors);
+  if (Object.hasOwn(contract ?? {}, "longDescription")) {
+    errors.push("publicDistribution.longDescription must use canonical longDescription");
+  }
+  if (contract?.fullDisplayName !== `${definition?.displayName} (${contract?.publicDisplayName})`) {
+    errors.push("fullDisplayName must combine canonical displayName and publicDisplayName");
+  }
+
+  const prompts = contract?.defaultPrompt;
+  if (!Array.isArray(prompts) || prompts.length !== LISTING_LIMITS.promptCount) {
+    errors.push(`defaultPrompt must contain exactly ${LISTING_LIMITS.promptCount} prompts`);
+  } else {
+    prompts.forEach((prompt, index) => within(prompt, LISTING_LIMITS.promptLength, `defaultPrompt[${index}]`, errors));
+  }
+  for (const [name, value] of Object.entries(contract?.urls ?? {})) {
+    try {
+      const url = new URL(value);
+      if (url.protocol !== "https:") errors.push(`${name} URL must use HTTPS`);
+    } catch {
+      errors.push(`${name} URL is invalid`);
+    }
+  }
+  for (const name of ["website", "privacy", "terms", "support"]) {
+    if (!contract?.urls?.[name]) errors.push(`${name} URL is required`);
+  }
+  if (contract?.publisher?.verificationState !== "unverified") {
+    errors.push("publisher verificationState must remain unverified without portal evidence");
+  }
+  if (!contract?.availability || !Array.isArray(contract.availability.countries) || !Array.isArray(contract.availability.regions) || !Array.isArray(contract.availability.workspaceContexts)) {
+    errors.push("availability decision record is incomplete");
+  }
+
+  const allowedStates = new Set(["common", "codex-specific", "chatgpt-specific", "advisory", "unavailable", "unverified"]);
+  if (capabilityMatrix?.releaseVersion !== definition?.version) errors.push("capability matrix version must match definition");
+  if (!Array.isArray(capabilityMatrix?.capabilities) || capabilityMatrix.capabilities.length === 0) errors.push("capability matrix is empty");
+  for (const capability of capabilityMatrix?.capabilities ?? []) {
+    if (!allowedStates.has(capability.state)) errors.push(`capability ${capability.id ?? "unknown"} has invalid state`);
+    requiredString(capability.evidenceClass, `capability ${capability.id} evidenceClass`, errors);
+    requiredString(capability.evidenceRef, `capability ${capability.id} evidenceRef`, errors);
+  }
+
+  if (reviewerCases?.releaseVersion !== definition?.version) errors.push("reviewer cases version must match definition");
+  const cases = reviewerCases?.cases ?? [];
+  if (cases.filter((entry) => entry.kind === "positive").length < 5) errors.push("at least five positive reviewer cases are required");
+  if (cases.filter((entry) => entry.kind === "negative").length < 3) errors.push("at least three negative reviewer cases are required");
+  for (const entry of cases) {
+    for (const field of ["id", "kind", "theme", "prompt", "expectedWorkflow", "expectedResult"]) requiredString(entry[field], `${entry.id ?? "case"}.${field}`, errors);
+    if (!Array.isArray(entry.prerequisites)) errors.push(`${entry.id}.prerequisites must be an array`);
+  }
+  for (const theme of ["missing-approval", "disproportionate-fit", "unavailable-repository-authority", "unsupported-host-capability", "unauthorized-external-action"]) {
+    if (!cases.some((entry) => entry.kind === "negative" && entry.theme === theme)) errors.push(`negative reviewer theme ${theme} is required`);
+  }
+  requiredString(releaseNotes, "releaseNotes", errors);
+  if (typeof releaseNotes === "string" && !releaseNotes.includes(definition?.version)) errors.push("release notes must contain exact version");
+  return errors;
+}
+
+export function assertPublicPluginContract(inputs) {
+  const errors = validatePublicPluginContract(inputs);
+  if (errors.length) throw new Error(`AGDF_PUBLIC_PLUGIN_CONTRACT_INVALID: ${errors.join("; ")}`);
+}

package/lib/public-plugin/manifest.js

@@ -0,0 +1,72 @@
+function publicValues(definition) {
+  const distribution = definition.publicDistribution;
+  if (!distribution || distribution.schemaVersion !== 1) {
+    throw new Error("AGDF_PUBLIC_PLUGIN_CONTRACT_INVALID: publicDistribution schemaVersion 1 is required");
+  }
+  return distribution;
+}
+
+export function createCodexPluginManifest(definition, { publicCandidate = false } = {}) {
+  const distribution = publicValues(definition);
+  const pluginInterface = publicCandidate ? {
+    displayName: distribution.publicDisplayName,
+    shortDescription: distribution.shortDescription,
+    longDescription: definition.longDescription,
+    defaultPrompt: distribution.defaultPrompt,
+  } : {
+    displayName: definition.displayName,
+    shortDescription: definition.description,
+    longDescription: definition.longDescription,
+    defaultPrompt: definition.codex.defaultPrompt,
+  };
+  const manifest = {
+    name: definition.id,
+    version: definition.version,
+    description: definition.description,
+    author: definition.author,
+    homepage: definition.homepage,
+    repository: definition.repository,
+    license: definition.license,
+    keywords: definition.keywords,
+    skills: definition.codex.skills,
+    interface: {
+      displayName: pluginInterface.displayName,
+      shortDescription: pluginInterface.shortDescription,
+      longDescription: pluginInterface.longDescription,
+      developerName: distribution.developerName,
+      category: distribution.category,
+      capabilities: definition.codex.capabilities,
+      websiteURL: distribution.urls.website,
+      privacyPolicyURL: distribution.urls.privacy,
+      termsOfServiceURL: distribution.urls.terms,
+      supportURL: distribution.urls.support,
+      composerIcon: definition.codex.composerIcon,
+      logo: definition.codex.logo,
+      defaultPrompt: pluginInterface.defaultPrompt,
+      brandColor: definition.brandColor,
+    },
+  };
+  if (!publicCandidate) manifest.hooks = `./${definition.codex.hooks}`;
+  return manifest;
+}
+
+export function renderCodexPluginManifest(definition, options) {
+  return `${JSON.stringify(createCodexPluginManifest(definition, options), null, 2)}\n`;
+}
+
+export function createClaudePluginManifest(definition) {
+  return {
+    name: definition.id,
+    version: definition.version,
+    description: definition.longDescription,
+    keywords: definition.keywords,
+    homepage: definition.homepage,
+    repository: definition.repository,
+    license: definition.license,
+    author: definition.author,
+  };
+}
+
+export function renderClaudePluginManifest(definition) {
+  return `${JSON.stringify(createClaudePluginManifest(definition), null, 2)}\n`;
+}