create-agdf 0.11.4 → 0.13.0

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`;
+}

package/lib/public-plugin/report.js

@@ -0,0 +1,33 @@
+export function createReadinessReport({ definition, fileCount, inventoryDigest }) {
+  const contract = definition.publicDistribution;
+  return {
+    schemaVersion: 1,
+    releaseVersion: definition.version,
+    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: `${fileCount} inventoried files; inventory digest ${inventoryDigest}` },
+      installed_host: { state: "unverified", detail: "PPD-L02 and PPD-L03 not performed" },
+      portal: { state: "unverified", detail: contract.publisher.verificationState },
+      post_publication: { state: "unverified", detail: "not published" },
+    },
+    externalState: {
+      publisherIdentity: contract.publisher.verificationState,
+      availability: contract.availability.decisionState,
+      portal: "not_observed",
+      publication: "not_observed",
+    },
+  };
+}
+
+export function renderReadinessReport(report) {
+  const blockers = report.submissionBlockers.map((blocker) => `- ${blocker}`).join("\n");
+  return `# AGDF Public Plugin Readiness\n\n- release: \`${report.releaseVersion}\`\n- candidate_state: \`${report.candidateState}\`\n- submission_ready: \`${report.submissionReady}\`\n\n## Evidence classes\n\n| Class | State | Detail |\n|---|---|---|\n${Object.entries(report.evidence).map(([name, value]) => `| ${name} | ${value.state} | ${value.detail} |`).join("\n")}\n\n## Submission blockers\n\n${blockers}\n\nRepository and bundle evidence do not prove installation, authenticated host behavior, publisher identity, portal state, deployment or publication.\n`;
+}

package/lib/public-plugin/validator.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { LISTING_LIMITS, unicodeLength } from "./contract.js";
+
+function inside(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+}
+
+function hasExactCase(root, target) {
+  const rel = relative(root, target);
+  let current = root;
+  for (const segment of rel.split(sep)) {
+    if (!readdirSync(current).includes(segment)) return false;
+    current = join(current, segment);
+  }
+  return true;
+}
+
+export function listCandidateFiles(root) {
+  root = realpathSync(resolve(root));
+  const files = [];
+  function visit(directory) {
+    for (const name of readdirSync(directory).sort()) {
+      const path = join(directory, name);
+      const stats = lstatSync(path);
+      if (stats.isSymbolicLink()) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: symlink not allowed: ${relative(root, path)}`);
+      if (stats.isDirectory()) visit(path);
+      else if (stats.isFile()) files.push(relative(root, path).replaceAll("\\", "/"));
+    }
+  }
+  visit(root);
+  return files;
+}
+
+function declaredPath(root, value, label, { directory = false } = {}) {
+  if (typeof value !== "string" || !value.startsWith("./")) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: ${label} must start with ./`);
+  const target = resolve(root, value);
+  if (!inside(root, target)) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: ${label} escapes candidate root`);
+  if (!hasExactCase(root, target)) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: ${label} has case mismatch or is missing`);
+  const actual = realpathSync(target);
+  if (!inside(root, actual)) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: ${label} resolves outside candidate root`);
+  const stats = statSync(target);
+  if (directory ? !stats.isDirectory() : !stats.isFile()) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: ${label} has wrong type`);
+}
+
+function assertReferencedSkillResources(root) {
+  const skillsRoot = join(root, "skills");
+  for (const skillName of readdirSync(skillsRoot).sort()) {
+    const skillRoot = join(skillsRoot, skillName);
+    if (!statSync(skillRoot).isDirectory()) continue;
+    const skillPath = join(skillRoot, "SKILL.md");
+    if (!statSync(skillPath).isFile()) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: skills/${skillName}/SKILL.md`);
+    const content = readFileSync(skillPath, "utf8");
+    const references = [...content.matchAll(/\.\.\/\.\.\/meta\/([A-Za-z0-9._/-]+)/g)].map((match) => match[1].replace(/[`)\],.;:]+$/, ""));
+    for (const reference of references) {
+      const target = resolve(root, "meta", reference);
+      if (!inside(root, target) || !statSync(target).isFile()) throw new Error(`AGDF_PUBLIC_PLUGIN_BUNDLE_PATH_MISSING: skills/${skillName} references meta/${reference}`);
+    }
+  }
+}
+
+export function validateCandidate(root) {
+  root = realpathSync(resolve(root));
+  const manifestPath = join(root, ".codex-plugin", "plugin.json");
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  if (manifest.hooks || manifest.mcp || manifest.app) throw new Error("AGDF_PUBLIC_PLUGIN_CONTRACT_INVALID: Skills-only candidate must not declare hooks, MCP or app configuration");
+  declaredPath(root, manifest.skills, "skills", { directory: true });
+  declaredPath(root, manifest.interface?.composerIcon, "composerIcon");
+  declaredPath(root, manifest.interface?.logo, "logo");
+  const definition = JSON.parse(readFileSync(join(root, "meta", "agdf-plugin.definition.json"), "utf8"));
+  if (definition.version !== manifest.version) throw new Error("AGDF_PUBLIC_PLUGIN_VERSION_DRIFT: manifest and definition differ");
+  for (const [label, source] of Object.entries(definition.publicDistribution?.submissionSources ?? {})) {
+    declaredPath(root, `./${source}`, `submissionSources.${label}`);
+  }
+  assertReferencedSkillResources(root);
+  if (unicodeLength(manifest.interface?.displayName) > LISTING_LIMITS.displayName) throw new Error("AGDF_PUBLIC_PLUGIN_LISTING_LIMIT_EXCEEDED: displayName");
+  if (unicodeLength(manifest.interface?.shortDescription) > LISTING_LIMITS.shortDescription) throw new Error("AGDF_PUBLIC_PLUGIN_LISTING_LIMIT_EXCEEDED: shortDescription");
+  if (unicodeLength(manifest.interface?.developerName) > LISTING_LIMITS.developerName) throw new Error("AGDF_PUBLIC_PLUGIN_LISTING_LIMIT_EXCEEDED: developerName");
+  const prompts = manifest.interface?.defaultPrompt ?? [];
+  if (prompts.length !== LISTING_LIMITS.promptCount || prompts.some((prompt) => unicodeLength(prompt) > LISTING_LIMITS.promptLength)) throw new Error("AGDF_PUBLIC_PLUGIN_LISTING_LIMIT_EXCEEDED: defaultPrompt");
+  for (const field of ["websiteURL", "privacyPolicyURL", "termsOfServiceURL", "supportURL"]) {
+    let url;
+    try { url = new URL(manifest.interface?.[field]); } catch { throw new Error(`AGDF_PUBLIC_PLUGIN_CONTRACT_INVALID: ${field}`); }
+    if (url.protocol !== "https:") throw new Error(`AGDF_PUBLIC_PLUGIN_CONTRACT_INVALID: ${field} must use HTTPS`);
+  }
+  const files = listCandidateFiles(root);
+  for (const forbidden of [".app.json", ".mcp.json", ".agdf/control/", "node_modules/", ".git/"]) {
+    if (files.some((file) => file === forbidden || file.startsWith(forbidden))) throw new Error(`AGDF_PUBLIC_PLUGIN_CONTRACT_INVALID: forbidden candidate content ${forbidden}`);
+  }
+  return { manifest, files };
+}
+
+export function inventory(root, { exclude = [] } = {}) {
+  const excluded = new Set(exclude);
+  return listCandidateFiles(root).filter((path) => !excluded.has(path)).map((path) => ({
+    path,
+    sha256: createHash("sha256").update(readFileSync(join(root, path))).digest("hex"),
+  }));
+}

package/lib/skill-evals/live-recorder.js

@@ -1,8 +1,7 @@
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { guardedExecFileSync } from "../delivery-path-search/transports/read-only-guard.js";
+import { executeStructuredAgent } from "../live-agent/read-only-structured.js";
 import { gradeCase } from "./index.js";
 import { changedPaths, disposeFixture, materializeFixture, mutationViolations, snapshotWorkspace, workspaceEvidence } from "./workspace.js";
 
@@ -43,29 +42,7 @@ function promptFor(skillSource, routingSource, testCase, fixtureDefinition, fixt
 }
 
 function defaultExecute({ surface, cwd, prompt, model, timeoutMs = 120000 }) {
-  if (surface === "codex") {
-    const temp = mkdtempSync(join(tmpdir(), "agdf-live-codex-"));
-    try {
-      const schemaPath = join(temp, "schema.json");
-      const outputPath = join(temp, "output.json");
-      writeFileSync(schemaPath, `${JSON.stringify(outputSchema, null, 2)}\n`, "utf8");
-      const args = ["exec", "--sandbox", "read-only", "--ephemeral", "--ignore-user-config", "--skip-git-repo-check", "--output-schema", schemaPath, "--output-last-message", outputPath, "--color", "never"];
-      if (model) args.push("--model", model);
-      args.push(prompt);
-      guardedExecFileSync("codex", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs });
-      return readFileSync(outputPath, "utf8");
-    } finally { rmSync(temp, { recursive: true, force: true }); }
-  }
-  if (surface === "claude") {
-    const args = ["-p", "--disallowedTools", "Edit,Write,Bash", "--output-format", "json", "--json-schema", JSON.stringify(outputSchema)];
-    if (model) args.push("--model", model);
-    args.push(prompt);
-    const raw = guardedExecFileSync("claude", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: timeoutMs });
-    const envelope = JSON.parse(raw);
-    if (envelope.is_error) throw new Error(`claude live adapter failed: ${envelope.result ?? "unknown error"}`);
-    return envelope.result;
-  }
-  throw new Error(`unsupported live surface: ${surface}`);
+  return executeStructuredAgent({ surface, cwd, prompt, model, outputSchema, timeoutMs });
 }
 
 export function persistLiveObservation(path, result) {

package/opencode-plugin.js

@@ -1,8 +1,20 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { evaluateOpenCodeRepositoryActivation } from "./lib/installers/opencode-activation.js";
 
 const packageJson = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8"));
 
+const readValidatorExpectedVersion = () => {
+  try {
+    const validatorPath = new URL("../../agdf/bin/agdf-local.js", import.meta.url);
+    if (!existsSync(validatorPath)) return null;
+    const content = readFileSync(validatorPath, "utf8");
+    const match = content.match(/expectedVersion["']?\s*[:=]\s*["']([^"']+)["']/);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+};
+
 export const AGDFPlugin = async ({ directory, client }) => {
   const controlDir = `${directory}/.agdf/control`;
   const activation = () => evaluateOpenCodeRepositoryActivation(directory);
@@ -47,6 +59,12 @@ export const AGDFPlugin = async ({ directory, client }) => {
     output[key].push(activation().active ? activeGuidance : inactiveGuidance);
   };
 
+  const safeToast = async (message, variant) => {
+    try {
+      if (client?.tui?.showToast) await client.tui.showToast({ body: { message, variant } });
+    } catch {}
+  };
+
   return {
     event: async ({ event }) => {
       if (event?.type === "session.created") {
@@ -59,6 +77,27 @@ export const AGDFPlugin = async ({ directory, client }) => {
             extra: currentStatus,
           },
         });
+        if (!currentStatus.active) {
+          await safeToast(
+            "AGDF: No valid .agdf/control/config.json. Run npx --yes @agdf/cli@latest opencode-repo to activate governance.",
+            "warning",
+          );
+        }
+        const validatorVersion = readValidatorExpectedVersion();
+        if (validatorVersion && validatorVersion !== packageJson.version) {
+          await client.app.log({
+            body: {
+              service: "agdf",
+              level: "warn",
+              message: `AGDF version drift: plugin ${packageJson.version} vs validator ${validatorVersion}`,
+              extra: { plugin_version: packageJson.version, validator_version: validatorVersion },
+            },
+          });
+          await safeToast(
+            `AGDF version drift: plugin ${packageJson.version} vs validator ${validatorVersion}. Run npx --yes @agdf/cli@latest opencode-repo to repair.`,
+            "warning",
+          );
+        }
       }
     },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-agdf",
-  "version": "0.11.4",
+  "version": "0.13.0",
   "description": "Bootstrap AGDF repository-local plugin files, Copilot/OpenCode instructions, skills, control files and machine-readable checks.",
   "type": "module",
   "files": [
@@ -21,6 +21,8 @@
   },
   "scripts": {
     "sync-package-assets": "node ./scripts/sync-package-assets.js",
+    "build:public-plugin": "node ./scripts/build-public-plugin.js",
+    "test:public-plugin": "node ./scripts/public-plugin-test.js",
     "test:delivery-path-search": "node ./scripts/delivery-path-search-test.js",
     "test:delivery-path-search-unit": "node ./scripts/delivery-path-search-unit-test.js",
     "test:delivery-path-search-generator": "node ./scripts/delivery-path-search-generator-test.js",
@@ -39,9 +41,12 @@
     "test:skill-evals": "node ./scripts/skill-evals-test.js",
     "eval:skills": "node ./scripts/run-skill-evals.js",
     "eval:skills:record": "node ./scripts/record-skill-evals.js",
+    "eval:proportionality:record": "node ./scripts/record-proportionality-benchmark.js",
+    "eval:proportionality": "node ./scripts/run-proportionality-benchmark.js",
+    "test:proportionality": "node ./scripts/proportionality-benchmark-test.js",
     "test:release-bootstrap": "node ./scripts/release-bootstrap-smoke-test.js",
     "test:routing": "npm run sync-package-assets && node ./scripts/test-routing.js",
-    "smoke-test": "npm run sync-package-assets && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:control-state && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:skill-evals && npm run eval:skills && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && npm run test:opencode-hardening && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
+    "smoke-test": "npm run sync-package-assets && npm run test:public-plugin && npm run test:cli-modularization && npm run test:local-validator && npm run test:local-marketplace && npm run test:package-build && npm run test:package-contents && npm run test:lifecycle && npm run test:control-state && npm run test:interaction-presentation && npm run test:verified-change && npm run test:runtime-integrity-layout && npm run test:runtime-integrity-negative && npm run test:skill-evals && npm run eval:skills && npm run test:proportionality && npm run test:delivery-path-search && npm run test:delivery-path-search-unit && npm run test:delivery-path-search-generator && npm run test:opencode-hardening && node ./scripts/smoke-test.js && node ./scripts/test-routing.js",
     "prepack": "npm run sync-package-assets"
   },
   "keywords": [