create-agdf 0.13.8 → 0.14.2

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/runtime/local-validator.js

@@ -0,0 +1,239 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import process from "node:process";
+import {
+  INSTALLATION_PROVENANCE_FILE,
+  digestDirectory,
+  inspectCopilotPayloadInventory,
+  inspectGeneratedRepositoryMarketplace,
+  inspectInstallationProvenance,
+  validateDistributionProfiles,
+} from "./plugin-provenance.js";
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function canonicalPath(path) {
+  try { return realpathSync(path); } catch { return resolve(path); }
+}
+
+export { digestDirectory };
+
+function envelope(machineValidation, options, evidence = {}) {
+  return {
+    schema_version: "1",
+    machine_validation: machineValidation,
+    surface: options.surface,
+    expected_version: options.expectedVersion,
+    observed_version: evidence.observedVersion ?? null,
+    source: evidence.source ?? null,
+    registry_access: false,
+    distribution_profile: evidence.distributionProfile ?? null,
+    evidence_plane: evidence.evidencePlane ?? null,
+    canonical_version: evidence.canonicalVersion ?? options.expectedVersion ?? null,
+    plugin_version: evidence.pluginVersion ?? null,
+    runtime_digest: evidence.runtimeDigest ?? null,
+    source_digest: evidence.sourceDigest ?? null,
+    plugin_root: evidence.pluginRoot ?? null,
+    provenance_status: evidence.provenanceStatus ?? null,
+    ...(evidence.reason ? { reason: evidence.reason } : {}),
+  };
+}
+
+export function resolveLocalValidator(options) {
+  if (options.ownedPackageRoot) {
+    const packageManifest = readJson(join(options.ownedPackageRoot, "package.json"));
+    const observedVersion = packageManifest?.version ?? null;
+    if (!packageManifest) {
+      return { envelope: envelope("unavailable", options, { source: "config_local_package", evidencePlane: "opencode_config_local", distributionProfile: "opencode-config-local", reason: "package_missing" }) };
+    }
+    if (observedVersion !== options.expectedVersion) {
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "config_local_package", evidencePlane: "opencode_config_local", distributionProfile: "opencode-config-local" }) };
+    }
+    const entrypoint = join(options.ownedPackageRoot, "bin", "create-agdf.js");
+    if (!existsSync(entrypoint)) {
+      return { envelope: envelope("unavailable", options, { observedVersion, source: "config_local_package", evidencePlane: "opencode_config_local", distributionProfile: "opencode-config-local", reason: "entrypoint_missing" }) };
+    }
+    return {
+      envelope: envelope("owned_version_matched", options, { observedVersion, source: "config_local_package", evidencePlane: "opencode_config_local", distributionProfile: "opencode-config-local", provenanceStatus: "matched" }),
+      executable: process.execPath,
+      prefixArgs: [entrypoint],
+    };
+  }
+  const manifestPath = join(options.runtimeRoot, "runtime-manifest.json");
+  const manifestExists = existsSync(manifestPath);
+  const manifest = manifestExists ? readJson(manifestPath) : null;
+  if (manifestExists && !manifest) {
+    return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", reason: "manifest_invalid" }) };
+  }
+  if (manifest) {
+    const pluginRoot = canonicalPath(options.pluginRoot ?? join(options.runtimeRoot, ".."));
+    if (options.expectedPluginRoot && canonicalPath(options.expectedPluginRoot) !== pluginRoot) {
+      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, evidencePlane: "loaded_session", distributionProfile: "runtime-plugin", provenanceStatus: "mismatch", reason: "plugin_root_mismatch" }) };
+    }
+    const definition = readJson(join(pluginRoot, "meta", "agdf-plugin.definition.json"));
+    const profile = validateDistributionProfiles(definition);
+    if (profile.status !== "matched") {
+      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, distributionProfile: "runtime-plugin", provenanceStatus: "invalid", reason: "profile_invalid" }) };
+    }
+    const codexManifest = readJson(join(pluginRoot, ".codex-plugin", "plugin.json"));
+    const claudeManifest = readJson(join(pluginRoot, ".claude-plugin", "plugin.json"));
+    const copilotManifest = readJson(join(pluginRoot, "plugin.json"));
+    const copilotProfile = Boolean(copilotManifest && !codexManifest && !claudeManifest);
+    const distributionProfile = copilotProfile ? "copilot-runtime-plugin" : "runtime-plugin";
+    const pluginVersion = copilotProfile ? copilotManifest?.version ?? null : codexManifest?.version ?? null;
+    if (copilotProfile
+      ? copilotManifest.version !== definition.version
+      : (!codexManifest || !claudeManifest || claudeManifest.version !== definition.version)) {
+      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile, provenanceStatus: "invalid", reason: "manifest_invalid" }) };
+    }
+    const copilotInventory = copilotProfile ? inspectCopilotPayloadInventory(pluginRoot, definition.version) : null;
+    if (copilotProfile && copilotInventory.status !== "matched") {
+      return { envelope: envelope("version_mismatch", options, { source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile, provenanceStatus: "invalid", reason: copilotInventory.reason }) };
+    }
+    const packageRoot = join(options.runtimeRoot, "create-agdf");
+    if (!existsSync(packageRoot)) {
+      return { envelope: envelope("unavailable", options, { source: "plugin_bundle", pluginRoot, pluginVersion, distributionProfile, reason: "runtime_missing" }) };
+    }
+    const packageManifest = readJson(join(packageRoot, "package.json"));
+    const observedVersion = packageManifest?.version ?? manifest.version ?? null;
+    if (observedVersion !== options.expectedVersion || manifest.version !== options.expectedVersion) {
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, distributionProfile }) };
+    }
+    let observedDigest = null;
+    try { observedDigest = digestDirectory(packageRoot); } catch {}
+    if (!observedDigest || manifest.digest !== observedDigest) {
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile, reason: "runtime_digest_mismatch" }) };
+    }
+    const entrypoint = resolve(options.runtimeRoot, manifest.entrypoint ?? "");
+    const entrypointRelative = relative(options.runtimeRoot, entrypoint);
+    if (!manifest.entrypoint || entrypointRelative === ".." || entrypointRelative.startsWith(`..${sep}`) || isAbsolute(entrypointRelative)) {
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile, reason: "invalid_entrypoint" }) };
+    }
+    if (!existsSync(entrypoint)) {
+      return { envelope: envelope("unavailable", options, { observedVersion, source: "plugin_bundle", pluginRoot, pluginVersion, canonicalVersion: definition.version, runtimeDigest: observedDigest, distributionProfile, reason: "entrypoint_missing" }) };
+    }
+    const installed = existsSync(join(pluginRoot, INSTALLATION_PROVENANCE_FILE));
+    let provenanceStatus = "not_applicable";
+    let sourceDigest = null;
+    let evidencePlane = options.expectedPluginRoot ? "loaded_session" : "installed_plugin_root";
+    if (installed) {
+      const provenance = inspectInstallationProvenance(pluginRoot, {
+        definition,
+        runtimeManifest: manifest,
+        pluginVersion,
+        profileId: distributionProfile,
+        inventoryDigest: copilotInventory?.inventoryDigest ?? null,
+      });
+      provenanceStatus = provenance.status;
+      sourceDigest = provenance.marker?.source_digest ?? null;
+      if (provenance.status !== "matched") {
+        return { envelope: envelope("version_mismatch", options, {
+          observedVersion,
+          source: "plugin_bundle",
+          pluginRoot,
+          pluginVersion,
+          canonicalVersion: definition.version,
+          runtimeDigest: observedDigest,
+          sourceDigest,
+          distributionProfile,
+          evidencePlane,
+          provenanceStatus,
+          reason: provenance.reason,
+        }) };
+      }
+    } else if (existsSync(join(pluginRoot, ".agdf-local-install.json"))) {
+      return { envelope: envelope("unavailable", options, {
+        observedVersion,
+        source: "plugin_bundle",
+        pluginRoot,
+        pluginVersion,
+        canonicalVersion: definition.version,
+        runtimeDigest: observedDigest,
+        distributionProfile,
+        evidencePlane: "loaded_session",
+        provenanceStatus: "missing",
+        reason: "installation_provenance_missing",
+      }) };
+    } else {
+      const generatedRepository = copilotProfile ? null : inspectGeneratedRepositoryMarketplace(resolve(pluginRoot, "..", ".."));
+      if (pluginVersion !== definition.version
+          || (!copilotProfile && (generatedRepository.status !== "matched"
+            || canonicalPath(generatedRepository.pluginRoot) !== pluginRoot))) {
+        return { envelope: envelope("unavailable", options, {
+          observedVersion,
+          source: "plugin_bundle",
+          pluginRoot,
+          pluginVersion,
+          canonicalVersion: definition.version,
+          runtimeDigest: observedDigest,
+          distributionProfile,
+          evidencePlane: "installed_plugin_root",
+          provenanceStatus: "missing",
+          reason: "installation_provenance_missing",
+        }) };
+      }
+      evidencePlane = "generated_bundle";
+    }
+    return {
+      envelope: envelope("owned_version_matched", options, {
+        observedVersion,
+        source: "plugin_bundle",
+        pluginRoot,
+        pluginVersion,
+        canonicalVersion: definition.version,
+        runtimeDigest: observedDigest,
+        sourceDigest,
+        distributionProfile,
+        evidencePlane,
+        provenanceStatus,
+      }),
+      executable: process.execPath,
+      prefixArgs: [entrypoint],
+    };
+  }
+
+  const configuredPath = options.configuredPath ?? process.env.AGDF_VALIDATOR_PATH ?? "";
+  if (configuredPath) {
+    if (!isAbsolute(configuredPath) || !existsSync(configuredPath)) {
+      return { envelope: envelope("unavailable", options, { source: "configured_path", reason: "invalid_absolute_path" }) };
+    }
+    const versionProbe = spawnSync(configuredPath, ["--version", "--json"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    let observedVersion = null;
+    try { observedVersion = JSON.parse(versionProbe.stdout)?.version ?? null; } catch {}
+    if (versionProbe.status !== 0 || observedVersion !== options.expectedVersion) {
+      return { envelope: envelope("version_mismatch", options, { observedVersion, source: "configured_path" }) };
+    }
+    return {
+      envelope: envelope("configured_version_matched", options, { observedVersion, source: "configured_path" }),
+      executable: configuredPath,
+      prefixArgs: [],
+    };
+  }
+
+  return { envelope: envelope(options.externalRequired ? "external_required" : "unavailable", options) };
+}
+
+export function runLocalValidator(options, args, io = console) {
+  const resolved = resolveLocalValidator(options);
+  if (args[0] === "--resolve-only") {
+    io.log(JSON.stringify(resolved.envelope, null, args.includes("--json") ? 2 : 0));
+    return resolved.executable ? 0 : 2;
+  }
+  if (!resolved.executable) {
+    io.error(JSON.stringify(resolved.envelope));
+    return 2;
+  }
+  const child = spawnSync(resolved.executable, [...resolved.prefixArgs, ...args], {
+    cwd: options.cwd ?? process.cwd(),
+    env: { ...process.env, AGDF_MACHINE_VALIDATION: resolved.envelope.machine_validation },
+    stdio: "inherit",
+  });
+  return child.status ?? 2;
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/runtime/plugin-provenance.js

@@ -0,0 +1,255 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+
+export const INSTALLATION_PROVENANCE_FILE = ".agdf-installation.json";
+export const LEGACY_LOCAL_INSTALL_FILE = ".agdf-local-install.json";
+export const COPILOT_PAYLOAD_INVENTORY_FILE = ".agdf-payload-inventory.json";
+
+const EXPECTED_PROFILES = Object.freeze({
+  "source-development": Object.freeze({ runtime: "absent", installable: false, machineValidation: "unavailable" }),
+  "runtime-plugin": Object.freeze({ runtime: "required", installable: true, machineValidation: "local_exact_version_digest" }),
+  "copilot-runtime-plugin": Object.freeze({ runtime: "required", installable: true, machineValidation: "local_exact_version_digest_inventory" }),
+  "opencode-config-local": Object.freeze({ runtime: "config_local_package", installable: true, machineValidation: "local_exact_version" }),
+  "portable-skills": Object.freeze({ runtime: "absent", installable: true, machineValidation: "unavailable_or_external_required" }),
+});
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function digestDirectory(root) {
+  const files = [];
+  function visit(directory) {
+    for (const name of readdirSync(directory).sort()) {
+      const path = join(directory, name);
+      const stats = statSync(path);
+      if (stats.isDirectory()) visit(path);
+      else if (stats.isFile()) files.push(path);
+    }
+  }
+  visit(root);
+  const hash = createHash("sha256");
+  for (const path of files) {
+    hash.update(relative(root, path).replaceAll("\\", "/"));
+    hash.update("\0");
+    hash.update(readFileSync(path));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function digestFile(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+
+export function inspectCopilotPayloadInventory(pluginRoot, expectedVersion) {
+  const inventoryPath = join(pluginRoot, COPILOT_PAYLOAD_INVENTORY_FILE);
+  const inventory = readJson(inventoryPath);
+  if (!inventory || inventory.schema_version !== 1 || inventory.profile_id !== "copilot-runtime-plugin"
+      || inventory.version !== expectedVersion || !Array.isArray(inventory.entries)) {
+    return { status: "invalid", reason: "copilot_payload_inventory_invalid" };
+  }
+  const destinations = inventory.entries.map((entry) => entry.destination);
+  if (new Set(destinations).size !== destinations.length) {
+    return { status: "invalid", reason: "copilot_payload_inventory_duplicate" };
+  }
+  const actual = [];
+  function visit(directory) {
+    for (const name of readdirSync(directory).sort()) {
+      const path = join(directory, name);
+      const stats = statSync(path);
+      if (stats.isDirectory()) visit(path);
+      else if (stats.isFile()) {
+        const normalized = relative(pluginRoot, path).replaceAll("\\", "/");
+        if (![COPILOT_PAYLOAD_INVENTORY_FILE, INSTALLATION_PROVENANCE_FILE, LEGACY_LOCAL_INSTALL_FILE].includes(normalized)) actual.push(normalized);
+      }
+    }
+  }
+  try { visit(pluginRoot); } catch { return { status: "invalid", reason: "copilot_payload_incomplete" }; }
+  if (JSON.stringify(actual.sort()) !== JSON.stringify([...destinations].sort())) {
+    return { status: "invalid", reason: "copilot_payload_inventory_mismatch" };
+  }
+  for (const entry of inventory.entries) {
+    const path = join(pluginRoot, entry.destination);
+    if (!existsSync(path) || digestFile(path) !== entry.digest || statSync(path).size !== entry.bytes) {
+      return { status: "invalid", reason: "copilot_payload_digest_mismatch", entry: entry.destination };
+    }
+  }
+  const excluded = actual.some((path) => path.startsWith("skills/") || path.startsWith(".codex-plugin/")
+    || path.startsWith(".claude-plugin/") || path.startsWith("submission/")
+    || path === "hooks/hooks.json" || path === "hooks/session-start.sh");
+  if (excluded) return { status: "invalid", reason: "copilot_payload_excluded_surface" };
+  return { status: "matched", inventory, inventoryDigest: digestFile(inventoryPath) };
+}
+
+export function digestNormalizedPluginSource(root, canonicalVersion) {
+  const files = [];
+  function visit(directory) {
+    for (const name of readdirSync(directory).sort()) {
+      const path = join(directory, name);
+      const stats = statSync(path);
+      if (stats.isDirectory()) visit(path);
+      else if (stats.isFile()) files.push(path);
+    }
+  }
+  visit(root);
+  const hash = createHash("sha256");
+  for (const path of files) {
+    const normalizedPath = relative(root, path).replaceAll("\\", "/");
+    if ([INSTALLATION_PROVENANCE_FILE, LEGACY_LOCAL_INSTALL_FILE].includes(normalizedPath)) continue;
+    let content = readFileSync(path);
+    if (normalizedPath === ".codex-plugin/plugin.json") {
+      const manifest = readJson(path);
+      if (!manifest) throw new Error(`Invalid Codex plugin manifest: ${path}`);
+      content = `${JSON.stringify({ ...manifest, version: canonicalVersion }, null, 2)}\n`;
+    }
+    hash.update(normalizedPath);
+    hash.update("\0");
+    hash.update(content);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function validateDistributionProfiles(definition) {
+  const contract = definition?.distributionProfiles;
+  if (contract?.schemaVersion !== 1) return { status: "invalid", reason: "profile_invalid" };
+  if (contract.marketplaceIdentities?.durable !== "agdf"
+      || contract.marketplaceIdentities?.generatedRepository !== "agdf-repo") {
+    return { status: "invalid", reason: "profile_invalid" };
+  }
+  for (const [profileId, expected] of Object.entries(EXPECTED_PROFILES)) {
+    const observed = contract.profiles?.[profileId];
+    if (!observed
+        || Object.keys(observed).length !== Object.keys(expected).length
+        || Object.keys(expected).some((key) => observed[key] !== expected[key])) {
+      return { status: "invalid", reason: "profile_invalid" };
+    }
+  }
+  if (Object.keys(contract.profiles ?? {}).length !== Object.keys(EXPECTED_PROFILES).length) {
+    return { status: "invalid", reason: "profile_invalid" };
+  }
+  return { status: "matched", contract };
+}
+
+export function inspectGeneratedRepositoryMarketplace(targetDir) {
+  const marketplacePath = join(targetDir, ".agents", "plugins", "marketplace.json");
+  if (!existsSync(marketplacePath)) return { status: "absent", marketplacePath };
+  const marketplace = readJson(marketplacePath);
+  const plugin = marketplace?.plugins?.length === 1 ? marketplace.plugins[0] : null;
+  const pluginPath = plugin?.source?.source === "local" ? plugin.source.path : null;
+  if (marketplace?.name !== "agdf-repo" || plugin?.name !== "agdf" || pluginPath !== "./plugins/agdf") {
+    return { status: "invalid", reason: "repository_marketplace_invalid", marketplacePath };
+  }
+  const pluginRoot = resolve(targetDir, pluginPath);
+  const rel = relative(resolve(targetDir), pluginRoot);
+  if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    return { status: "invalid", reason: "repository_marketplace_path_escape", marketplacePath };
+  }
+  const definition = readJson(join(pluginRoot, "meta", "agdf-plugin.definition.json"));
+  const runtimeManifest = readJson(join(pluginRoot, "runtime", "runtime-manifest.json"));
+  const codexManifest = readJson(join(pluginRoot, ".codex-plugin", "plugin.json"));
+  const claudeManifest = readJson(join(pluginRoot, ".claude-plugin", "plugin.json"));
+  const runtimeRoot = join(pluginRoot, "runtime");
+  const runtimePackageRoot = join(pluginRoot, "runtime", "create-agdf");
+  const runtimeEntrypoint = resolve(runtimeRoot, runtimeManifest?.entrypoint ?? "");
+  const runtimeEntrypointRel = relative(runtimeRoot, runtimeEntrypoint);
+  if (validateDistributionProfiles(definition).status !== "matched"
+      || definition?.version !== runtimeManifest?.version
+      || codexManifest?.version !== definition?.version
+      || claudeManifest?.version !== definition?.version
+      || !/^[a-f0-9]{64}$/.test(runtimeManifest?.digest ?? "")
+      || !existsSync(join(runtimeRoot, "agdf-local.js"))
+      || !runtimeManifest?.entrypoint
+      || runtimeEntrypointRel === ".."
+      || runtimeEntrypointRel.startsWith(`..${sep}`)
+      || isAbsolute(runtimeEntrypointRel)
+      || !existsSync(runtimeEntrypoint)
+      || !existsSync(runtimePackageRoot)) {
+    return { status: "invalid", reason: "repository_runtime_incomplete", marketplacePath, pluginRoot };
+  }
+  let runtimeDigest;
+  try { runtimeDigest = digestDirectory(runtimePackageRoot); } catch {
+    return { status: "invalid", reason: "repository_runtime_incomplete", marketplacePath, pluginRoot };
+  }
+  if (runtimeDigest !== runtimeManifest.digest) {
+    return { status: "invalid", reason: "runtime_digest_mismatch", marketplacePath, pluginRoot };
+  }
+  return {
+    status: "matched",
+    marketplacePath,
+    pluginRoot,
+    selector: `${plugin.name}@${marketplace.name}`,
+    runtimeDigest,
+  };
+}
+
+export function inspectInstallationProvenance(pluginRoot, {
+  definition,
+  runtimeManifest,
+  pluginVersion,
+  allowLegacy = false,
+  profileId = "runtime-plugin",
+  inventoryDigest = null,
+} = {}) {
+  const markerPath = join(pluginRoot, INSTALLATION_PROVENANCE_FILE);
+  const legacyPath = join(pluginRoot, LEGACY_LOCAL_INSTALL_FILE);
+  if (!existsSync(markerPath)) {
+    if (allowLegacy && existsSync(legacyPath)) {
+      const marker = readJson(legacyPath);
+      if (!marker
+          || marker.schema_version !== 1
+          || marker.owner !== "create-agdf"
+          || marker.kind !== "codex_local_development_projection"
+          || marker.canonical_version !== definition.version
+          || marker.codex_install_version !== pluginVersion
+          || !/^[a-f0-9]{64}$/.test(marker.source_digest ?? "")) {
+        return { status: "invalid", reason: "installation_provenance_invalid", marker };
+      }
+      let observedSourceDigest;
+      try { observedSourceDigest = digestNormalizedPluginSource(pluginRoot, definition.version); } catch {
+        return { status: "invalid", reason: "source_digest_mismatch", marker };
+      }
+      return observedSourceDigest === marker.source_digest
+        ? { status: "legacy", marker, observedSourceDigest, reason: "legacy_installation_provenance" }
+        : { status: "invalid", reason: "source_digest_mismatch", marker, observedSourceDigest };
+    }
+    const profile = validateDistributionProfiles(definition);
+    if (profile.status !== "matched") return profile;
+    return { status: "missing", reason: "installation_provenance_missing" };
+  }
+  const profile = validateDistributionProfiles(definition);
+  if (profile.status !== "matched") return profile;
+  const marker = readJson(markerPath);
+  if (!marker
+      || marker.schema_version !== 1
+      || marker.owner !== "create-agdf"
+      || marker.profile_id !== profileId
+      || marker.marketplace_id !== profile.contract.marketplaceIdentities.durable
+      || marker.canonical_version !== definition.version
+      || marker.codex_install_version !== pluginVersion
+      || marker.runtime_digest !== runtimeManifest?.digest
+      || (profileId === "copilot-runtime-plugin" && marker.inventory_digest !== inventoryDigest)
+      || !/^[a-f0-9]{64}$/.test(marker.source_digest ?? "")) {
+    return { status: "invalid", reason: "installation_provenance_invalid", marker };
+  }
+  let observedSourceDigest;
+  try {
+    observedSourceDigest = digestNormalizedPluginSource(pluginRoot, definition.version);
+  } catch {
+    return { status: "invalid", reason: "source_digest_mismatch", marker };
+  }
+  if (observedSourceDigest !== marker.source_digest) {
+    return { status: "invalid", reason: "source_digest_mismatch", marker, observedSourceDigest };
+  }
+  return { status: "matched", marker, observedSourceDigest };
+}
+
+export const distributionProfileContract = Object.freeze({
+  expectedProfiles: EXPECTED_PROFILES,
+});

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/runtime/validator-application.js

@@ -0,0 +1,40 @@
+import process from "node:process";
+import { createValidationHandlers } from "../cli/validation-handlers.js";
+import { validateCommandOptions } from "../cli/command-registry.js";
+import { CliUsageError, parseArgs } from "../cli/parse-args.js";
+import { pluginDefinition } from "../cli/runtime-context.js";
+
+const validatorCommands = new Set(["doctor", "gate-check", "delivery-map", "delivery-path-search"]);
+
+export async function runValidatorCli(argv = process.argv.slice(2), adapters = {}) {
+  const io = adapters.io ?? console;
+  if (argv.includes("--version")) {
+    const output = { name: "create-agdf", version: pluginDefinition.version };
+    io.log(argv.includes("--json") ? JSON.stringify(output) : output.version);
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseArgs(argv, adapters.parser);
+  } catch (error) {
+    if (!(error instanceof CliUsageError)) throw error;
+    io.error(error.message);
+    return error.exitCode;
+  }
+  if (parsed.kind === "help") {
+    io.log("AGDF surface-local validator: doctor | gate-check | delivery-map | delivery-path-search");
+    return 0;
+  }
+  let options;
+  try {
+    options = validateCommandOptions(parsed.options);
+  } catch (error) {
+    io.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (!validatorCommands.has(options.target)) {
+    io.error(`The surface-local validator does not support lifecycle command: ${options.target}`);
+    return 1;
+  }
+  return await createValidationHandlers(io).get(options.target)(options);
+}

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/runtime-check-consent/contract.js

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+
+const OPERATIONS = Object.freeze([
+  "resolve-local-runtime",
+  "inspect-control-state",
+  "render-bounded-orientation",
+]);
+
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+}
+
+export function validateRuntimeCheckCapability(capability) {
+  if (capability?.schemaVersion !== 1 || capability.capabilityId !== "automatic-runtime-checks") {
+    throw new Error("AGDF_RUNTIME_CHECK_CAPABILITY_INVALID: schema or capability id");
+  }
+  if (!Number.isInteger(capability.adapterContractVersion) || capability.adapterContractVersion < 1) {
+    throw new Error("AGDF_RUNTIME_CHECK_CAPABILITY_INVALID: adapter contract version");
+  }
+  if (capability.entrypoint !== "runtime/agdf-session-check.js") {
+    throw new Error("AGDF_RUNTIME_CHECK_CAPABILITY_INVALID: fixed entrypoint required");
+  }
+  if (JSON.stringify(capability.operations) !== JSON.stringify(OPERATIONS)) {
+    throw new Error("AGDF_RUNTIME_CHECK_CAPABILITY_INVALID: closed operation vocabulary required");
+  }
+  const constraints = capability.constraints ?? {};
+  if (constraints.arguments !== "forbidden" || constraints.filesystemWrites !== "forbidden"
+      || constraints.network !== "forbidden" || constraints.gateAuthority !== "none") {
+    throw new Error("AGDF_RUNTIME_CHECK_CAPABILITY_INVALID: read-only constraints required");
+  }
+  const surfaces = capability.surfaces ?? {};
+  if (surfaces.codex !== "native-hook-review" || surfaces.claude !== "exact-command-rule"
+      || surfaces.copilot !== "plugin-hook-review"
+      || surfaces.opencode !== "plugin-internal"
+      || surfaces["portable-skills"] !== "manual-external-required") {
+    throw new Error("AGDF_RUNTIME_CHECK_CAPABILITY_INVALID: surface contract");
+  }
+  return capability;
+}
+
+export function runtimeCheckCapabilityIdentity({ capability, surface, runtimeDigest, sourceDigest, command }) {
+  validateRuntimeCheckCapability(capability);
+  if (!["codex", "claude", "copilot", "opencode"].includes(surface)) throw new Error("AGDF_RUNTIME_CHECK_SURFACE_INVALID");
+  for (const [name, value] of Object.entries({ runtimeDigest, sourceDigest })) {
+    if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw new Error(`AGDF_RUNTIME_CHECK_IDENTITY_INVALID: ${name}`);
+  }
+  if (typeof command !== "string" || !command.trim()) throw new Error("AGDF_RUNTIME_CHECK_IDENTITY_INVALID: command");
+  const payload = stable({
+    schema_version: 1,
+    surface,
+    capability,
+    runtime_digest: runtimeDigest,
+    source_digest: sourceDigest,
+    command: command.trim(),
+  });
+  return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+
+export function fixedRuntimeCheckCommand(surface, pluginRoot, platform = process.platform) {
+  if (surface === "opencode") return "plugin:agdf:automatic-runtime-checks";
+  if (surface === "copilot") return 'node "${PLUGIN_ROOT}/runtime/agdf-session-check.js"';
+  if (surface === "codex" || surface === "claude") {
+    return platform === "win32"
+      ? "node \"$([Environment]::GetEnvironmentVariable('PLUGIN_ROOT') + [Environment]::GetEnvironmentVariable('CLAUDE_PLUGIN_ROOT'))\\runtime\\agdf-session-check.js\""
+      : "node \"${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT}}/runtime/agdf-session-check.js\"";
+  }
+  const normalizedRoot = platform === "win32" ? pluginRoot.replaceAll("/", "\\") : pluginRoot;
+  return `node \"${normalizedRoot}${platform === "win32" ? "\\" : "/"}runtime${platform === "win32" ? "\\" : "/"}agdf-session-check.js\"`;
+}
+
+export const runtimeCheckOperations = OPERATIONS;

package/generated/plugins/copilot/agdf/runtime/create-agdf/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@agdf/local-validator-runtime",
+  "version": "0.14.2",
+  "private": true,
+  "type": "module"
+}

package/generated/plugins/copilot/agdf/runtime/runtime-manifest.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": "1",
+  "generated": true,
+  "source": "create-agdf/cli",
+  "version": "0.14.2",
+  "entrypoint": "create-agdf/bin/agdf-validator.js",
+  "digest": "51035c8735d47aa727980d82709326071b372464ae077a1d269aadc0d30f2624"
+}

package/generated/submissions/openai/agdf/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.13.8",
+  "version": "0.14.2",
   "description": "Control layer for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",
@@ -30,7 +30,6 @@
     "websiteURL": "https://agdf.iself.eu",
     "privacyPolicyURL": "https://agdf.iself.eu/privacy",
     "termsOfServiceURL": "https://agdf.iself.eu/terms",
-    "supportURL": "https://agdf.iself.eu/support",
     "composerIcon": "./assets/agdf-icon.svg",
     "logo": "./assets/agdf-logo.svg",
     "defaultPrompt": [