create-agdf 0.14.4 → 0.20.0

package/lib/runtime/control-command-service.js

@@ -0,0 +1,12 @@
+import { executeApprovalCommand } from "#agdf-core/control-state/approval-command.js";
+import { evaluateGateCheck } from "#agdf-core/control-evaluation/gate-check.js";
+import { cliGitObservation } from "../control-evaluation/git-observation.js";
+import { pluginDefinition } from "./control-context.js";
+
+const evaluateLocalGate = (root, selection) => evaluateGateCheck(root, selection, cliGitObservation);
+
+export function recordGateApprovalCommand(root, command) {
+  return executeApprovalCommand(root, command, {
+    evaluateGateCheck: evaluateLocalGate, packageVersion: pluginDefinition.version,
+  });
+}

package/lib/runtime/control-context.js

@@ -0,0 +1,11 @@
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createResourceContext, resources as coreResources, configuredLanguage as configured, resolveConfiguredChatLanguage as resolveLanguage } from "#agdf-core/resources/context.js";
+const packageURL = new URL("../../", import.meta.url);
+const generatedURL = new URL("../../generated/", import.meta.url);
+const contractsURL = coreResources.packageRoot === fileURLToPath(packageURL)
+  ? pathToFileURL(`${coreResources.contractsRoot}/`)
+  : new URL("plugins/agdf/meta/contracts/", generatedURL);
+export const resources = createResourceContext({ packageURL, generatedURL, contractsURL });
+export const { packageRoot, generatedRoot, pluginDefinition, interactionLocales } = resources;
+export const configuredLanguage = value => configured(value, resources);
+export const resolveConfiguredChatLanguage = target => resolveLanguage(target, resources);

package/lib/runtime/git-history.js

@@ -0,0 +1,7 @@
+import { execFileSync } from "node:child_process";
+export function readGitHistory(root, path) {
+  const git = args => execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 10000, maxBuffer: 1024 * 1024 });
+  return git(["log", "--all", "--follow", "--format=%H", "--", path]).trim().split(/\r?\n/u).filter(Boolean).slice(0, 25).flatMap(commit => {
+    try { return [{ path, commit, content: git(["show", `${commit}:${path}`]) }]; } catch { return []; }
+  });
+}

package/lib/runtime/git-originals.js

@@ -0,0 +1,36 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { isSafeControlRelativePath } from "#agdf-core/control-state/contained-file.js";
+import { directoryIdentity } from "#agdf-core/control-state/run-store-inspection.js";
+import { canonicalRunText } from "#agdf-core/control-state/run-seal.js";
+const textDigest = content => `sha256:${createHash("sha256").update(canonicalRunText(content)).digest("hex")}`;
+function git(root, args) {
+  return execFileSync("git", args, { cwd: root, stdio: ["ignore", "pipe", "ignore"], timeout: 3000, maxBuffer: 2 * 1024 * 1024 });
+}
+
+// Search only this checkout's current history and the exact referenced path. Git is a source
+// of original bytes, never proof of a historical approval. Symlink/tree objects are not sources.
+export function readGitOriginals(root, path) {
+  if (!isSafeControlRelativePath(path)) return [];
+  try {
+    directoryIdentity(git(root, ["rev-parse", "--show-toplevel"]).toString().replace(/\r?\n$/u, ""));
+    // Git resolves Windows short/long directory aliases; filesystem-relative paths do not.
+    const prefix = git(root, ["rev-parse", "--show-prefix"]).toString().replace(/\r?\n$/u, "");
+    const objectPath = `${prefix}${path}`;
+    if (!isSafeControlRelativePath(objectPath)) return [];
+    const commits = [...new Set([git(root, ["rev-parse", "HEAD"]).toString().trim(),
+      ...git(root, ["log", "-8", "--format=%H", "--", path]).toString().trim().split(/\r?\n/u)])]
+      .filter((commit) => /^[0-9a-f]{40,64}$/u.test(commit));
+    const originals = [];
+    for (const commit of commits) {
+      try {
+        const tree = git(root, ["ls-tree", "--full-tree", "-z", commit, "--", objectPath]).toString();
+        if (!/^100(?:644|755) blob [0-9a-f]+\t/u.test(tree) || tree.slice(tree.indexOf("\t") + 1, -1) !== objectPath) continue;
+        const bytes = git(root, ["show", `${commit}:${objectPath}`]);
+        originals.push({ path, git_path: objectPath, source: "git", commit, digest: textDigest(bytes.toString("utf8")), bytes: bytes.toString("base64") });
+      } catch { /* Missing or oversized objects require manual recovery. */ }
+    }
+    return originals;
+  } catch { return []; }
+}
+

package/lib/runtime/local-validator.js

@@ -2,6 +2,8 @@ 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 { resolveHostCommand } from "../host-command.js";
+import { runtimeEnvironment } from "../skill-dispatch/binding.js";
 import {
   INSTALLATION_PROVENANCE_FILE,
   digestDirectory,
@@ -9,7 +11,7 @@ import {
   inspectGeneratedRepositoryMarketplace,
   inspectInstallationProvenance,
   validateDistributionProfiles,
-} from "./plugin-provenance.js";
+} from "#agdf-core/runtime/plugin-provenance.js";
 
 function readJson(path) {
   try {
@@ -25,6 +27,23 @@ function canonicalPath(path) {
 
 export { digestDirectory };
 
+const PLUGIN_HOST_SURFACES = new Set(["codex", "claude", "copilot", "opencode", "plugin"]);
+
+export function resolvePluginHostEnvironment(env = process.env, { defaultSurface = "plugin" } = {}) {
+  const fallbackSurface = PLUGIN_HOST_SURFACES.has(defaultSurface) ? defaultSurface : "plugin";
+  const requestedSurface = env.AGDF_SURFACE
+    || (env.COPILOT_PLUGIN_DATA ? "copilot"
+      : env.PLUGIN_ROOT ? "codex"
+        : env.CLAUDE_PLUGIN_ROOT ? "claude" : fallbackSurface);
+  const surface = PLUGIN_HOST_SURFACES.has(requestedSurface) ? requestedSurface : fallbackSurface;
+  const expectedPluginRoot = surface === "claude"
+    ? env.CLAUDE_PLUGIN_ROOT || env.PLUGIN_ROOT || undefined
+    : ["codex", "copilot", "plugin"].includes(surface)
+      ? env.PLUGIN_ROOT || (surface === "codex" ? env.CLAUDE_PLUGIN_ROOT : undefined) || undefined
+      : undefined;
+  return Object.freeze({ surface, expectedPluginRoot });
+}
+
 function envelope(machineValidation, options, evidence = {}) {
   return {
     schema_version: "1",
@@ -204,7 +223,13 @@ export function resolveLocalValidator(options) {
     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 command;
+    try {
+      command = resolveHostCommand(configuredPath);
+    } catch {
+      return { envelope: envelope("unavailable", options, { source: "configured_path", reason: "unsupported_command_shim" }) };
+    }
+    const versionProbe = spawnSync(command.executable, [...command.prefixArgs, "--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) {
@@ -212,8 +237,8 @@ export function resolveLocalValidator(options) {
     }
     return {
       envelope: envelope("configured_version_matched", options, { observedVersion, source: "configured_path" }),
-      executable: configuredPath,
-      prefixArgs: [],
+      executable: command.executable,
+      prefixArgs: command.prefixArgs,
     };
   }
 
@@ -221,6 +246,7 @@ export function resolveLocalValidator(options) {
 }
 
 export function runLocalValidator(options, args, io = console) {
+  const wrapperStart = process.hrtime.bigint().toString();
   const resolved = resolveLocalValidator(options);
   if (args[0] === "--resolve-only") {
     io.log(JSON.stringify(resolved.envelope, null, args.includes("--json") ? 2 : 0));
@@ -232,7 +258,15 @@ export function runLocalValidator(options, args, io = console) {
   }
   const child = spawnSync(resolved.executable, [...resolved.prefixArgs, ...args], {
     cwd: options.cwd ?? process.cwd(),
-    env: { ...process.env, AGDF_MACHINE_VALIDATION: resolved.envelope.machine_validation },
+    env: {
+      ...process.env,
+      ...(resolved.executable === process.execPath ? runtimeEnvironment() : {}),
+      AGDF_MACHINE_VALIDATION: resolved.envelope.machine_validation,
+      AGDF_DISPATCH_WRAPPER_START_NS: wrapperStart,
+      AGDF_DISPATCH_PLUGIN_ROOT: resolved.envelope.plugin_root ?? "",
+      AGDF_DISPATCH_RUNTIME_DIGEST: resolved.envelope.runtime_digest ?? "",
+      AGDF_DISPATCH_PROVENANCE_STATUS: resolved.envelope.provenance_status ?? "",
+    },
     stdio: "inherit",
   });
   return child.status ?? 2;

package/lib/runtime/plugin-provenance.js

@@ -1,298 +1 @@
-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 };
-}
-
-function classifyInstalledHistoricalProfile(catalogue, definition, classifyHistoricalProfile) {
-  if (typeof classifyHistoricalProfile !== "function") {
-    return { status: "invalid", reason: "profile_history_invalid" };
-  }
-  const result = classifyHistoricalProfile({
-    catalogue,
-    version: definition?.version,
-    distributionProfiles: definition?.distributionProfiles,
-  });
-  if (result.status !== "matched") return result;
-  return {
-    ...result,
-    contract: catalogue.contracts[result.contract_id].distribution_profiles,
-  };
-}
-
-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,
-  allowHistoricalProfilesForMigration = false,
-  distributionProfileHistory = null,
-  classifyHistoricalProfile = null,
-} = {}) {
-  const markerPath = join(pluginRoot, INSTALLATION_PROVENANCE_FILE);
-  const legacyPath = join(pluginRoot, LEGACY_LOCAL_INSTALL_FILE);
-  if (!existsSync(markerPath)) {
-    if (allowLegacy && existsSync(legacyPath)) {
-      const currentProfile = validateDistributionProfiles(definition);
-      if (Object.hasOwn(definition ?? {}, "distributionProfiles")
-          && currentProfile.status !== "matched") {
-        return allowHistoricalProfilesForMigration
-          ? classifyInstalledHistoricalProfile(distributionProfileHistory, definition, classifyHistoricalProfile).status === "matched"
-            ? { status: "invalid", reason: "installation_provenance_invalid" }
-            : classifyInstalledHistoricalProfile(distributionProfileHistory, definition, classifyHistoricalProfile)
-          : currentProfile;
-      }
-      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 currentProfile = validateDistributionProfiles(definition);
-  const historicalProfile = currentProfile.status !== "matched" && allowHistoricalProfilesForMigration
-    ? classifyInstalledHistoricalProfile(distributionProfileHistory, definition, classifyHistoricalProfile)
-    : null;
-  if (currentProfile.status !== "matched" && historicalProfile?.status !== "matched") {
-    return historicalProfile ?? currentProfile;
-  }
-  const profile = currentProfile.status === "matched" ? currentProfile : historicalProfile;
-  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,
-    profileClassification: historicalProfile ? "supported_historical" : "current",
-    historicalReleaseVersion: historicalProfile?.release_version ?? null,
-    historicalContractId: historicalProfile?.contract_id ?? null,
-    historicalContractDigest: historicalProfile?.contract_digest ?? null,
-    historicalEntryDigest: historicalProfile?.entry_digest ?? null,
-  };
-}
-
-export const distributionProfileContract = Object.freeze({
-  expectedProfiles: EXPECTED_PROFILES,
-});
+export * from "#agdf-core/runtime/plugin-provenance.js";

package/lib/runtime/runtime-probe.js

@@ -0,0 +1,61 @@
+import { spawnSync } from "node:child_process";
+import { statSync } from "node:fs";
+import { dirname, isAbsolute } from "node:path";
+import process from "node:process";
+const PROBE = 'process.stdout.write("AGDF_RUNTIME_OK:"+process.versions.node)';
+const RUNTIME_PROBE_TIMEOUT_MS = 5_000;
+const text = value => typeof value === "string" && value.length > 0 && value.length <= 4096 && !/[\r\n\0]/u.test(value);
+const absolute = value => text(value) && isAbsolute(value);
+export function runtimeEnvironment(versions = process.versions) {
+  if (!text(versions.node)) throw new Error("unsupported_runtime");
+  return Object.freeze(versions.electron ? { ELECTRON_RUN_AS_NODE: "1" } : {});
+}
+
+function fileIdentity(path, stat) {
+  if (!absolute(path)) throw new Error("runtime_unavailable");
+  try {
+    const s = stat(path);
+    if (!s.isFile()) throw new Error();
+    return [s.dev, s.ino, s.size, s.mtimeMs, s.ctimeMs];
+  } catch { throw new Error("runtime_unavailable"); }
+}
+
+export function createRuntimeProbe({ spawn = spawnSync, stat = statSync } = {}) {
+  let cached;
+  return ({ executable = process.execPath, versions = process.versions } = {}) => {
+    const environment = runtimeEnvironment(versions);
+    // Bootstrap options can execute preload modules before the fixed probe. Never probe
+    // an inherited module-loading configuration or silently change the advertised tuple.
+    if (process.env.NODE_OPTIONS || process.env.NODE_PATH) {
+      cached = null;
+      throw new Error("runtime_bootstrap_environment_unsupported");
+    }
+    const identity = JSON.stringify([executable, fileIdentity(executable, stat), versions.node,
+      versions.electron ?? null, versions.bun ?? null, environment,
+      process.env.NODE_OPTIONS ?? null, process.env.NODE_PATH ?? null]);
+    if (cached?.identity === identity) return cached.launch;
+    cached = null;
+    const child = spawn(executable, ["-e", PROBE], {
+      cwd: dirname(executable), env: { ...process.env, ...environment },
+      encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], shell: false,
+      timeout: RUNTIME_PROBE_TIMEOUT_MS, maxBuffer: 4096, windowsHide: true,
+    });
+    // Electron may emit OS diagnostics on stderr despite a successful exact probe.
+    // Nonzero exit, signal, timeout, output overflow and unexpected stdout still fail.
+    if (child.error || child.status !== 0 || child.signal
+        || child.stdout !== `AGDF_RUNTIME_OK:${versions.node}`) {
+      throw new Error("runtime_probe_failed");
+    }
+    // Do not cache a tuple whose executable was replaced during the probe.
+    const after = JSON.stringify([executable, fileIdentity(executable, stat), versions.node,
+      versions.electron ?? null, versions.bun ?? null, environment,
+      process.env.NODE_OPTIONS ?? null, process.env.NODE_PATH ?? null]);
+    if (after !== identity) throw new Error("runtime_identity_changed");
+    const launch = Object.freeze({ executable, environment });
+    cached = { identity, launch };
+    return launch;
+  };
+}
+
+const probeRuntime = createRuntimeProbe();
+

package/lib/runtime/validator-application.js

@@ -1,10 +1,10 @@
 import process from "node:process";
 import { createValidationHandlers } from "../cli/validation-handlers.js";
-import { validateCommandOptions } from "../cli/command-registry.js";
+import { validateCommandOptions, commandGroupRoutes } 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"]);
+const validatorCommands = new Set(["target-check", "skill-dispatch", "doctor", "gate-check", "delivery-map", "delivery-path-search", "contract", "control-maintenance", "run-create", "run-present", "run-update", "run-revise", "run-step", "run-approve", ...Object.keys(commandGroupRoutes)]);
 
 export async function runValidatorCli(argv = process.argv.slice(2), adapters = {}) {
   const io = adapters.io ?? console;
@@ -22,7 +22,7 @@ export async function runValidatorCli(argv = process.argv.slice(2), adapters = {
     return error.exitCode;
   }
   if (parsed.kind === "help") {
-    io.log("AGDF surface-local validator: doctor | gate-check | delivery-map | delivery-path-search");
+    io.log("AGDF surface-local validator: target-check | skill-dispatch | doctor | gate-check | delivery-map | delivery-path-search | contract | control-maintenance | run-create | run-present | run-update | run-revise | run-step | run-approve");
     return 0;
   }
   let options;

package/lib/runtime-check-consent/adapters.js

@@ -1,42 +1,3 @@
-function fixedCommand(command) {
-  if (typeof command !== "string" || !command.trim() || /[\n\r;&|*?]/.test(command)) {
-    throw new Error("AGDF_RUNTIME_CHECK_COMMAND_NOT_EXACT");
-  }
-  return command.trim();
-}
-
-export function codexRuntimeCheckEvidence({ capabilityIdentity, observedIdentity, hookEnabled, reviewRequired = false }) {
-  if (hookEnabled && observedIdentity === capabilityIdentity) return { status: "enabled", capability_identity: capabilityIdentity, reason: "none" };
-  if (observedIdentity && observedIdentity !== capabilityIdentity) return { status: "renewal_required", reason: "capability_identity_changed" };
-  return { status: "decision_required", reason: reviewRequired ? "host_review_required" : "host_permission_unverified" };
-}
-
-export function claudePermissionRule({ platform, command }) {
-  const exact = fixedCommand(command);
-  return platform === "win32" ? `PowerShell(${exact})` : `Bash(${exact})`;
-}
-
-export function applyClaudeExactRule(settings, { rule, deny = [], ask = [] }) {
-  if (!settings || typeof settings !== "object" || Array.isArray(settings)) throw new Error("AGDF_CLAUDE_SETTINGS_INVALID");
-  if ([...deny, ...ask].includes(rule)) return { status: "degraded", reason: "host_permission_conflict", settings };
-  const next = structuredClone(settings);
-  next.permissions ??= {};
-  if (Array.isArray(next.permissions.allow) && next.permissions.allow.some((entry) => entry.includes("*") || entry !== entry.trim())) {
-    throw new Error("AGDF_CLAUDE_BROAD_OR_MALFORMED_RULE");
-  }
-  next.permissions.allow = [...new Set([...(next.permissions.allow ?? []), rule])];
-  return { status: "configured", reason: "none", settings: next };
-}
-
-export function revokeClaudeExactRule(settings, rule) {
-  const next = structuredClone(settings);
-  if (Array.isArray(next.permissions?.allow)) next.permissions.allow = next.permissions.allow.filter((entry) => entry !== rule);
-  return next;
-}
-
-export function openCodeRuntimeCheckEvidence({ capabilityIdentity, observedIdentity, packageLoadable, hookObserved }) {
-  if (!packageLoadable) return { status: "unavailable", reason: "unsupported_host_capability" };
-  if (observedIdentity !== capabilityIdentity) return { status: "renewal_required", reason: "installed_identity_mismatch" };
-  if (!hookObserved) return { status: "degraded", reason: "host_permission_unverified" };
-  return { status: "enabled", capability_identity: capabilityIdentity, reason: "none" };
-}
+export { codexRuntimeCheckEvidence, projectCodexHookObservation } from "../host-adapters/codex/runtime-check.js";
+export { ownedRuntimeCheckRules, revokeClaudeExactRule } from "../host-adapters/claude/permission-rules.js";
+export { openCodeRuntimeCheckEvidence } from "../host-adapters/opencode/runtime-check.js";

package/lib/runtime-check-consent/claude-settings.js

@@ -2,8 +2,8 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writ
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import process from "node:process";
-import { renameSyncWithRetry } from "../fs-swap.js";
-import { applyClaudeExactRule, revokeClaudeExactRule } from "./adapters.js";
+import { renameSyncWithRetry } from "#agdf-core/fs-swap.js";
+import { revokeClaudeExactRule } from "../host-adapters/claude/permission-rules.js";
 
 export function defaultClaudeSettingsPath({ env = process.env, home = homedir() } = {}) {
   return join(resolve(env.CLAUDE_CONFIG_DIR || join(home, ".claude")), "settings.json");
@@ -41,27 +41,6 @@ function atomicSettingsWrite(path, settings) {
   }
 }
 
-export function configureClaudeExactRuntimeRule({ path = defaultClaudeSettingsPath(), rule }) {
-  const before = readClaudeSettings(path);
-  const permissions = before.settings.permissions ?? {};
-  const applied = applyClaudeExactRule(before.settings, {
-    rule,
-    deny: Array.isArray(permissions.deny) ? permissions.deny : [],
-    ask: Array.isArray(permissions.ask) ? permissions.ask : [],
-  });
-  if (applied.status !== "configured") return { ...applied, path, rollback() {} };
-  atomicSettingsWrite(path, applied.settings);
-  return {
-    status: "configured",
-    reason: "host_permission_unverified",
-    path,
-    rollback() {
-      if (before.exists) atomicSettingsWrite(path, before.settings);
-      else rmSync(path, { force: true });
-    },
-  };
-}
-
 export function revokeClaudeRuntimeRule({ path = defaultClaudeSettingsPath(), rule }) {
   const before = readClaudeSettings(path);
   if (!before.exists) return { status: "manual", reason: "configuration_missing", path };