create-agdf 0.13.7 → 0.14.1

package/README.md

@@ -24,11 +24,36 @@ Use a different target when Codex is not your agent surface:
 | Surface or goal | Start with | What it gives you |
 |---|---|---|
 | Claude Code | `npx --yes @agdf/cli@latest claude` | The AGDF plugin for Claude Code. |
+| GitHub Copilot | `npx --yes @agdf/cli@latest copilot` | The AGDF plugin with prefixed skills and a consent-bound session hook. |
 | OpenCode, user-wide discovery | `npx --yes @agdf/cli@latest opencode` | The npm plugin and global native skills; repository governance remains opt-in. |
 | OpenCode, one repository | `npx --yes @agdf/cli@latest opencode-repo` | Durable control configuration that activates the once-installed global runtime. |
-| GitHub Copilot | `npx --yes @agdf/cli@latest copilot` | Repository instructions, visible skills and control templates. |
 | Durable control state in an existing setup | `npx --yes @agdf/cli@latest init` | Live `.agdf/control/` state when the repository explicitly needs it. |
 
+The runtime-bearing `codex`, `claude`, `copilot` and `opencode` installers ask before enabling narrow automatic
+local checks on an interactive terminal. The choices are `enable`, `manual` and `cancel`; enablement
+is never preselected. Every interactive installation or update asks again. A previous choice is
+shown only as intent, never as proof of effective host permission. The prompt shows the target AGDF
+version and the result shows the verified installed version or transition. Matching capability
+identity may preserve host-native trust, but it never
+suppresses the installer choice. Non-interactive installation defaults to manual unless the exact
+option is provided:
+
+Interactive terminals accept `1` or `E` for enable, `2` or `M` for manual, `D` for technical
+details and `Esc` for immediate cancel without Enter. The primary choice uses beginner-safe language,
+keeps the material consent facts visible and has no preselected option. Manual mode explains that
+AGDF remains available on request; invalid keys redisplay the valid choices.
+
+```sh
+npx --yes @agdf/cli@latest claude --runtime-checks enable
+npx --yes @agdf/cli@latest runtime-checks status --surface claude --json
+```
+
+The check is argument-free, read-only and offline. Consent is content-bound, reversible and separate
+from AGDF gate approval. A receipt alone never proves effective host permission. Codex native trust,
+Claude deny/ask precedence and all explicit OpenCode permissions remain authoritative. The public
+Skills-only OpenAI candidate has no runtime or hooks and therefore remains manual/external for this
+capability.
+
 For prerequisites, all surface-specific flows and operational boundaries, use the authoritative [installation guide](../INSTALL.md). Do not run `init` merely to ask a fresh question: an agent can first clarify the request and ask for `Approval: UR` when durable control state is needed.
 
 ## Command overview
@@ -41,6 +66,7 @@ Installation, activation and explicit lifecycle changes:
 npx --yes @agdf/cli@latest codex
 npx --yes @agdf/cli@latest codex-repo
 npx --yes @agdf/cli@latest claude
+npx --yes @agdf/cli@latest copilot
 npx --yes @agdf/cli@latest opencode
 npx --yes @agdf/cli@latest opencode-status
 npx --yes @agdf/cli@latest opencode-repo
@@ -79,11 +105,9 @@ Backward-compatible scaffold usage:
 npm create agdf@latest -- codex
 npm create agdf@latest -- codex-repo
 npm create agdf@latest -- claude
-npm create agdf@latest -- copilot
 npm create agdf@latest -- opencode
 npm create agdf@latest -- opencode-status
 npm create agdf@latest -- opencode-repo
-npm create agdf@latest -- both
 npm create agdf@latest -- init
 npm create agdf@latest -- config --language en
 npm create agdf@latest -- doctor
@@ -113,17 +137,17 @@ it does not localize the CLI lifecycle card.
 - `codex` installs the AGDF plugin globally for Codex
 - `codex-repo` writes a repository-local Codex marketplace under `.agents/plugins/` and a local AGDF plugin copy under `plugins/agdf/`
 - `claude` installs the AGDF plugin globally for Claude Code
-- `copilot` writes `AGENTS.md`, Copilot custom instructions under `.github/`, visible repository skills under `.github/skills/`, and AGDF control templates under `.agdf/control/`
+- `copilot` registers the AGDF-owned local Marketplace and installs `agdf@agdf` through Copilot CLI; when `copilot` is not on `PATH`, it runs the pinned official `@github/copilot` CLI package through npm, then verifies AGDF in Copilot's own plugin list
 - `opencode` installs the AGDF npm plugin and ten native skills as a user-wide OpenCode surface
 - `opencode-status` reports OpenCode global config, package loadability, global native-skill completeness, installed host/plugin-SDK versions, declaration-level support for AGDF's two experimental hooks, durable repository activation, legacy compatibility and observable session signals
 - `status` reports installation, repository activation and delivery separately without mutating state
+- `runtime-checks status|enable|manual` reports the requested/effective automatic-check state or gives the exact reinstall route needed to change it
 - `disable` writes a supported repository-local opt-out while retaining global capability and durable control state
 - `uninstall` previews and, only with `--confirm`, applies a selected global removal through supported native/owned operations
 - `opencode-repo` writes durable AGDF control configuration and templates under `.agdf/control/`; it does not copy a second OpenCode runtime surface
-- `both` writes the Codex repository-local marketplace plus the Copilot-facing repository files
 - `config` writes or updates only `.agdf/control/config.json` for an already installed plugin or an existing repository
 
-The `codex` and `claude` commands install from the complete plugin built into the released
+The `codex`, `claude` and `copilot` commands install from the complete plugin built into the released
 `create-agdf` package. They atomically stage it under an AGDF-owned user-data marketplace, register
 that stable local path through the host CLI and verify the exposed version. Source `plugin/` therefore
 contains no generated runtime bytes and the source checkout exposes no installable root marketplace.
@@ -133,7 +157,7 @@ checkout, npm cache, PATH or registry. Rerunning either command performs the exp
 migrates only the exact known legacy AGDF GitHub marketplace; foreign same-name registrations fail
 closed and failed host operations restore the prior owned stage.
 
-If the target repository already has an `AGENTS.md`, `create-agdf` preserves it and writes `AGENTS.agdf.md` instead of replacing your existing instructions. Merge the AGDF fragment into your current `AGENTS.md` when you want Copilot to load both instruction sets. The generated `.github/copilot-instructions.md` keeps Copilot pointed at `AGENTS.md`, `.github/skills/` and `.agdf/control/` without duplicating the full AGDF rule model. Use `--force` only when you explicitly want to overwrite generated files.
+The Copilot installer does not create, rewrite or remove repository files. Existing `AGENTS.md`, `.github/` and `.agdf/control/` content remains untouched. Use `init` separately when a repository should own surface-neutral durable AGDF control state.
 
 Use the `codex-repo` target when AGDF should be available only inside one repository instead of being installed as a personal/global Codex plugin.
 

package/generated/plugins/agdf/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.13.7",
+  "version": "0.14.1",
   "description": "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.",
   "keywords": [
     "agentic",

package/generated/plugins/agdf/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.13.7",
+  "version": "0.14.1",
   "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": [
@@ -39,6 +38,5 @@
       "Close this delivery run with an auditable AGDF report."
     ],
     "brandColor": "#14B8A6"
-  },
-  "hooks": "./hooks/hooks.json"
+  }
 }

package/generated/plugins/agdf/hooks/copilot-hooks.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "type": "command",
+        "command": "node \"${PLUGIN_ROOT}/runtime/agdf-session-check.js\"",
+        "env": {
+          "AGDF_SURFACE": "copilot"
+        },
+        "timeoutSec": 10
+      }
+    ]
+  }
+}

package/generated/plugins/agdf/hooks/hooks.json

@@ -5,8 +5,9 @@
                 "hooks": [
                     {
                         "type":         "command",
-                        "command":      "bash -lc 'hook=\"${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-}}/hooks/session-start.sh\"; if [ -f \"$hook\" ]; then exec bash \"$hook\"; fi; hook=\"$PWD/plugins/agdf/hooks/session-start.sh\"; if [ -f \"$hook\" ]; then exec bash \"$hook\"; fi; exit 0'",
-                        "statusMessage": "Loading AGDF..."
+                        "command":      "node \"${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT}}/runtime/agdf-session-check.js\"",
+                        "commandWindows": "node \"$([Environment]::GetEnvironmentVariable('PLUGIN_ROOT') + [Environment]::GetEnvironmentVariable('CLAUDE_PLUGIN_ROOT'))\\runtime\\agdf-session-check.js\"",
+                        "statusMessage": "Checking AGDF runtime state..."
                     }
                 ]
             }

package/generated/plugins/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.13.7",
+  "version": "0.14.1",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",
@@ -50,7 +50,10 @@
   },
   "copilot": {
     "skillPrefix": "agdf-",
-    "runtimeContractFileName": "agdf-runtime-contract.md"
+    "runtimeContractFileName": "agdf-runtime-contract.md",
+    "pluginManifest": "plugin.json",
+    "skills": "copilot-skills/",
+    "hooks": "hooks/copilot-hooks.json"
   },
   "opencode": {
     "skillPrefix": "agdf-",
@@ -68,6 +71,30 @@
       }
     }
   },
+  "automaticRuntimeChecks": {
+    "schemaVersion": 1,
+    "capabilityId": "automatic-runtime-checks",
+    "adapterContractVersion": 1,
+    "entrypoint": "runtime/agdf-session-check.js",
+    "operations": [
+      "resolve-local-runtime",
+      "inspect-control-state",
+      "render-bounded-orientation"
+    ],
+    "constraints": {
+      "arguments": "forbidden",
+      "filesystemWrites": "forbidden",
+      "network": "forbidden",
+      "gateAuthority": "none"
+    },
+    "surfaces": {
+      "codex": "native-hook-review",
+      "claude": "exact-command-rule",
+      "copilot": "plugin-hook-review",
+      "opencode": "plugin-internal",
+      "portable-skills": "manual-external-required"
+    }
+  },
   "interactions": {
     "fallback": "exact_text",
     "localeRegistry": "meta/agdf-interaction-locales.json",
@@ -120,6 +147,21 @@
         "authorizationPath": "exact_text",
         "technicalPermissionOwner": "claude_host"
       },
+      "copilot": {
+        "questionAdapter": "exact_text",
+        "availability": "always",
+        "gateSafety": "wait_for_deliberate_user_input",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline",
+          "cancel"
+        ],
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "copilot_host"
+      },
       "opencode": {
         "questionAdapter": "question",
         "availability": "when_permission_question_allows",

package/generated/plugins/agdf/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "agdf",
+  "version": "0.14.1",
+  "description": "Control layer for governed AI-assisted delivery.",
+  "author": {
+    "name": "Arndt Gold",
+    "url": "https://agdf.iself.eu"
+  },
+  "homepage": "https://agdf.iself.eu",
+  "repository": "https://github.com/arndtgold/ai-native-governance-delivery-framework",
+  "license": "Apache-2.0",
+  "keywords": [
+    "agentic",
+    "governance",
+    "delivery",
+    "ai-native",
+    "brownfield"
+  ],
+  "category": "Productivity",
+  "skills": "copilot-skills/",
+  "hooks": "hooks/copilot-hooks.json"
+}

package/generated/plugins/agdf/runtime/agdf-local.js

@@ -12,7 +12,7 @@ const manifest = JSON.parse(readFileSync(new URL("./runtime-manifest.json", impo
 process.exitCode = runLocalValidator({
   runtimeRoot,
   pluginRoot,
-  expectedPluginRoot: process.env.CLAUDE_PLUGIN_ROOT || undefined,
+  expectedPluginRoot: process.env.CLAUDE_PLUGIN_ROOT || process.env.PLUGIN_ROOT || undefined,
   expectedVersion: manifest.version,
   surface: process.env.AGDF_SURFACE || "plugin",
 }, process.argv.slice(2));

package/generated/plugins/agdf/runtime/agdf-session-check.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+// Generated by create-agdf/scripts/sync-plugin-runtime.js; do not edit.
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { digestNormalizedPluginSource } from "./create-agdf/lib/runtime/plugin-provenance.js";
+import { fixedRuntimeCheckCommand, runtimeCheckCapabilityIdentity } from "./create-agdf/lib/runtime-check-consent/contract.js";
+
+if (process.argv.length !== 2) {
+  console.error("AGDF automatic runtime check accepts no arguments.");
+  process.exitCode = 2;
+} else {
+  const surface = process.env.AGDF_SURFACE
+    || (process.env.CLAUDE_PLUGIN_ROOT ? "claude" : process.env.COPILOT_PLUGIN_DATA ? "copilot" : process.env.PLUGIN_ROOT ? "codex" : "");
+  const dataRoot = process.env.AGDF_DATA_DIR
+    || (process.platform === "darwin"
+      ? join(homedir(), "Library", "Application Support", "agdf")
+      : process.platform === "win32"
+        ? join(process.env.LOCALAPPDATA || process.env.APPDATA || join(homedir(), "AppData", "Local"), "agdf")
+        : join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "agdf"));
+  let consentEnabled = false;
+  if (["codex", "claude", "copilot", "opencode"].includes(surface)) {
+    try {
+      const receipt = JSON.parse(readFileSync(join(dataRoot, "runtime-checks", `${surface}.json`), "utf8"));
+      consentEnabled = receipt?.schema_version === 1
+        && receipt?.owner === "create-agdf"
+        && receipt?.capability_id === "automatic-runtime-checks"
+        && receipt?.surface === surface
+        && receipt?.requested_state === "enabled";
+      if (consentEnabled && ["codex", "claude", "copilot"].includes(surface)) {
+        const pluginRoot = fileURLToPath(new URL("../", import.meta.url));
+        const manifest = JSON.parse(readFileSync(new URL("./runtime-manifest.json", import.meta.url), "utf8"));
+        const definition = JSON.parse(readFileSync(new URL("../meta/agdf-plugin.definition.json", import.meta.url), "utf8"));
+        const currentIdentity = runtimeCheckCapabilityIdentity({
+          capability: definition.automaticRuntimeChecks,
+          surface,
+          runtimeDigest: manifest.digest,
+          sourceDigest: digestNormalizedPluginSource(pluginRoot, manifest.version),
+          command: fixedRuntimeCheckCommand(surface, pluginRoot, process.platform),
+        });
+        consentEnabled = receipt.capability_identity === currentIdentity;
+      }
+    } catch {}
+  }
+  if (!consentEnabled) process.exit(0);
+  const validator = fileURLToPath(new URL("./agdf-local.js", import.meta.url));
+  const pluginRoot = fileURLToPath(new URL("../", import.meta.url));
+  const child = spawnSync(process.execPath, [validator, "doctor", "--all-active", "--json"], {
+    cwd: process.cwd(),
+    env: { ...process.env, AGDF_SURFACE: process.env.AGDF_SURFACE || "plugin" },
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 10000,
+    maxBuffer: 1024 * 1024,
+  });
+  let message = "AGDF automatic runtime check: no governed control state was found; manual validation remains available.";
+  try {
+    const report = JSON.parse(child.stdout || "{}");
+    const status = report.status || "unknown";
+    const findings = report.summary?.findings ?? report.reports?.reduce((sum, item) => sum + (item.summary?.findings ?? 0), 0) ?? 0;
+    message = `AGDF automatic runtime check: status=${status} findings=${findings}. This is read-only technical evidence and never grants an AGDF approval.`;
+  } catch {}
+  const configPath = join(process.cwd(), ".agdf", "control", "config.json");
+  let configHint = "Project config: .agdf/control/config.json not found. Persist project language only when durable control is needed.";
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      configHint = `Project config: .agdf/control/config.json (artefacts=${config.artifact_language || "unset"}, chat=${config.chat_language || "unset"}, runtime=${config.runtime_language || "en"}).`;
+    } catch {
+      configHint = "Project config: .agdf/control/config.json is invalid. Run the surface-local doctor command manually.";
+    }
+  }
+  const additionalContext = [
+    "AGDF active.",
+    "",
+    message,
+    configHint,
+    "",
+    "Use the installed AGDF skills as workflow controls.",
+    "For a new build, change, extension, refactor, CLI, app, fix with product semantics, Structured Delivery request, unclear approval, or unclear next step, use gate-check before implementation or later-gate artefacts.",
+    "Do not print the full router or constitution unless the user asks for them.",
+    "Source of truth:",
+    `- ${join(pluginRoot, "meta", "agdf-agent-router.md")}`,
+    `- ${join(pluginRoot, "meta", "agdf-constitution.md")}`,
+    `- ${join(pluginRoot, "meta", "agdf-runtime-contract.md")}`,
+  ].join("\n");
+  if (surface === "copilot") {
+    console.log(JSON.stringify({ additionalContext }));
+  } else {
+    console.log(additionalContext);
+  }
+  process.exitCode = 0;
+}

package/generated/plugins/agdf/runtime/create-agdf/generated/plugins/agdf/meta/agdf-plugin.definition.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "agdf",
-  "version": "0.13.7",
+  "version": "0.14.1",
   "displayName": "AI Governance & Delivery Framework",
   "developerName": "Arndt Gold",
   "description": "Control layer for governed AI-assisted delivery.",
@@ -50,7 +50,10 @@
   },
   "copilot": {
     "skillPrefix": "agdf-",
-    "runtimeContractFileName": "agdf-runtime-contract.md"
+    "runtimeContractFileName": "agdf-runtime-contract.md",
+    "pluginManifest": "plugin.json",
+    "skills": "copilot-skills/",
+    "hooks": "hooks/copilot-hooks.json"
   },
   "opencode": {
     "skillPrefix": "agdf-",
@@ -68,6 +71,30 @@
       }
     }
   },
+  "automaticRuntimeChecks": {
+    "schemaVersion": 1,
+    "capabilityId": "automatic-runtime-checks",
+    "adapterContractVersion": 1,
+    "entrypoint": "runtime/agdf-session-check.js",
+    "operations": [
+      "resolve-local-runtime",
+      "inspect-control-state",
+      "render-bounded-orientation"
+    ],
+    "constraints": {
+      "arguments": "forbidden",
+      "filesystemWrites": "forbidden",
+      "network": "forbidden",
+      "gateAuthority": "none"
+    },
+    "surfaces": {
+      "codex": "native-hook-review",
+      "claude": "exact-command-rule",
+      "copilot": "plugin-hook-review",
+      "opencode": "plugin-internal",
+      "portable-skills": "manual-external-required"
+    }
+  },
   "interactions": {
     "fallback": "exact_text",
     "localeRegistry": "meta/agdf-interaction-locales.json",
@@ -120,6 +147,21 @@
         "authorizationPath": "exact_text",
         "technicalPermissionOwner": "claude_host"
       },
+      "copilot": {
+        "questionAdapter": "exact_text",
+        "availability": "always",
+        "gateSafety": "wait_for_deliberate_user_input",
+        "explicitOutcomes": [
+          "approve",
+          "revise",
+          "decline",
+          "cancel"
+        ],
+        "approvalValueTransport": "exact_option_value",
+        "waitSafety": "deliberate_no_auto_resolution",
+        "authorizationPath": "exact_text",
+        "technicalPermissionOwner": "copilot_host"
+      },
       "opencode": {
         "questionAdapter": "question",
         "availability": "when_permission_question_allows",

package/generated/plugins/agdf/runtime/create-agdf/lib/cli/command-registry.js

@@ -13,14 +13,14 @@ export const commandRegistry = Object.freeze([
   command("codex", { preferred: [""], scaffold: [""] }),
   command("codex-repo", { preferred: [""], scaffold: [""] }),
   command("claude", { preferred: [""], scaffold: [""] }),
-  command("copilot", { preferred: [""], scaffold: [""] }),
+  command("copilot", { preferred: [""] }),
   command("opencode", { preferred: [""], scaffold: [""] }),
   command("opencode-status", { preferred: [""], scaffold: [""] }),
   command("status", { preferred: [" [--surface <surface>] [--run <run_id>] [--json]"] }),
+  command("runtime-checks", { preferred: [" <status|enable|manual> --surface <codex|claude|copilot|opencode> [--json]"] }),
   command("disable", { preferred: [" --surface <surface> [--scope repository] [--dir <path>]"] }),
   command("uninstall", { preferred: [" --surface <surface> --scope global [--confirm]"] }),
   command("opencode-repo", { preferred: [""], scaffold: [""] }),
-  command("both", { scaffold: [""] }),
   command("init", { preferred: [""], scaffold: [""] }),
   command("config", { scaffold: [" --language de"] }),
   command("doctor", { local: [""], scaffold: [""], legacy: [" --json"] }),
@@ -65,6 +65,12 @@ export function validateCommandOptions(options) {
     throw new Error("uninstall requires explicit --scope global");
   }
   if (options.confirm && options.target !== "uninstall") throw new Error("--confirm is supported only by uninstall");
+  if (options.runtimeChecksDecision && !["codex", "claude", "copilot", "opencode"].includes(options.target)) {
+    throw new Error("--runtime-checks is supported only by codex, claude, copilot and opencode installation commands");
+  }
+  if (options.target === "runtime-checks" && !["codex", "claude", "copilot", "opencode"].includes(options.surface)) {
+    throw new Error("runtime-checks requires --surface codex, claude, copilot or opencode");
+  }
   if (options.approvalEnvelope && options.target !== "gate-check") throw new Error("--approval-envelope is supported only by gate-check");
   if (options.approvalEnvelope && (options.json || options.statusCard || options.allActive)) {
     throw new Error("--approval-envelope cannot be combined with --json, --status-card or --all-active");
@@ -120,6 +126,8 @@ Options:
   --scope <repository|global>
                  Select the lifecycle mutation scope
   --confirm      Apply a previously previewed global uninstall plan
+  --runtime-checks <enable|manual|cancel>
+                 Make the installation-time automatic-check decision explicitly; no TTY defaults to manual
   --fixture <path>
                  Use deterministic evaluator/candidate fixtures instead of a live evaluator
   --persist      Persist the redacted Delivery Path Search result under the current scope

package/generated/plugins/agdf/runtime/create-agdf/lib/cli/parse-args.js

@@ -45,6 +45,8 @@ export function parseArgs(argv, dependencies = {}) {
   let allActive = false;
   let scope;
   let confirm = false;
+  let runtimeChecksDecision;
+  let runtimeChecksAction;
 
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
@@ -60,6 +62,14 @@ export function parseArgs(argv, dependencies = {}) {
     if (arg === "--all-active") { allActive = true; continue; }
     if (arg === "--confirm") { confirm = true; continue; }
 
+    if (arg === "--runtime-checks") {
+      const next = requiredValue(args, i, arg);
+      if (!["enable", "manual", "cancel"].includes(next)) throw new CliUsageError("--runtime-checks must be enable, manual or cancel.");
+      runtimeChecksDecision = next;
+      i += 1;
+      continue;
+    }
+
     if (arg === "--run") {
       runId = requiredValue(args, i, arg);
       i += 1;
@@ -119,6 +129,11 @@ export function parseArgs(argv, dependencies = {}) {
       target = arg;
       continue;
     }
+    if (!arg.startsWith("-") && target === "runtime-checks" && !runtimeChecksAction) {
+      if (!["status", "enable", "manual"].includes(arg)) throw new CliUsageError("runtime-checks action must be status, enable or manual.");
+      runtimeChecksAction = arg;
+      continue;
+    }
     throw new CliUsageError(`Unknown argument: ${arg}`);
   }
 
@@ -147,6 +162,8 @@ export function parseArgs(argv, dependencies = {}) {
       allActive,
       scope,
       confirm,
+      runtimeChecksDecision,
+      runtimeChecksAction: runtimeChecksAction ?? "status",
       generatorModel,
       maxGeneratedCandidates,
       generationTimeoutMs,

package/generated/plugins/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/agdf/runtime/create-agdf/package.json

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

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

@@ -2,7 +2,7 @@
   "schema_version": "1",
   "generated": true,
   "source": "create-agdf/cli",
-  "version": "0.13.7",
+  "version": "0.14.1",
   "entrypoint": "create-agdf/bin/agdf-validator.js",
-  "digest": "05afaf9ec478d50900a79cbdda8fcd7c61fa5627f4770ba093b19908fa6df91b"
+  "digest": "724174653ad423b30654aa64a34e1699a18cc67037172c10aa249d1d61087116"
 }