create-agdf 0.13.6 → 0.13.8

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

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.13.6",
-  "digest": "c59609822c90c541d34c11633661287a963aa6a78bdfc4e9b2db7417bafb124f",
+  "releaseVersion": "0.13.8",
+  "digest": "3ada0c5f03ca8fa3d40b54c6682b617e651baea5db6926d07131fa29ea9fcb3a",
   "files": [
     {
       "path": ".codex-plugin/plugin.json",
-      "sha256": "d52166448d49d1fafa5b17f2385715f346191df330f2d8f853e59c674d30ecd0"
+      "sha256": "133bc0840f1be89ea0c3eb0909a26f758104ce0834da31e91a8fdf648102e296"
     },
     {
       "path": "assets/agdf-icon.svg",
@@ -29,7 +29,7 @@
     },
     {
       "path": "meta/agdf-plugin.definition.json",
-      "sha256": "a540f18c055960b6ecadb6bcd8f579444d58c267f89c121b2bfdb60dd40b2644"
+      "sha256": "d2b9b8f0134b9747be82f0fa1e9a99dd02a785aa8663514eb8bcc0648727fbf3"
     },
     {
       "path": "meta/agdf-runtime-contract.md",
@@ -157,23 +157,23 @@
     },
     {
       "path": "submission/openai/availability.md",
-      "sha256": "4d832dbb21f652982198ea261d9d0c816b224f9ec7fc1ddceef5355cd10c09eb"
+      "sha256": "1f3dd7874e1e3243ebeee6688fe5fb61a56b11db4212d02791e882e5cc82ee51"
     },
     {
       "path": "submission/openai/capability-matrix.json",
-      "sha256": "63bdcbba060a9b9026cb0e2b415f098c033d7b6d88164b26c2d3b5ee4cccfe6b"
+      "sha256": "f2e0e6e056f734b06942f5357d3aceb0750107d4989ced101a8aecb302e2f262"
     },
     {
       "path": "submission/openai/listing.json",
-      "sha256": "fd62fe03a9dff1b162e29536a4d547ce9b405afacc43545b6664b0678e1d50fe"
+      "sha256": "3fda29f5f5544d677f1cf26b7f566773f9e0c1ff0dfca689b0eeabf44d59ea9e"
     },
     {
       "path": "submission/openai/release-notes.md",
-      "sha256": "71e2041a170b2cfbeaac435462e9ee3e25f95e44572e4e62ef4e6cf99a59ce75"
+      "sha256": "bfd777b576a5387866df286a80fdc8b42552da45742fbe4c73f9a928c0320ef9"
     },
     {
       "path": "submission/openai/reviewer-cases.json",
-      "sha256": "6be33b0b545476ccaa3c346281aaf4fa204492a15ba119a0836ac4d92184afab"
+      "sha256": "df9946827c4102cd8eaedbfa4a6dd234098f85c82aa6d481c1634c7647362b2c"
     }
   ]
 }

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

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.13.6",
+  "releaseVersion": "0.13.8",
   "submissionType": "skills",
   "identity": {
     "technicalId": "agdf",

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

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.13.6",
+  "releaseVersion": "0.13.8",
   "candidateState": "repository_ready",
   "submissionReady": false,
   "submissionBlockers": [
@@ -16,7 +16,7 @@
     },
     "bundle": {
       "state": "pass",
-      "detail": "43 inventoried files; inventory digest c59609822c90c541d34c11633661287a963aa6a78bdfc4e9b2db7417bafb124f"
+      "detail": "43 inventoried files; inventory digest 3ada0c5f03ca8fa3d40b54c6682b617e651baea5db6926d07131fa29ea9fcb3a"
     },
     "installed_host": {
       "state": "unverified",

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

@@ -1,6 +1,6 @@
 # AGDF Public Plugin Readiness
 
-- release: `0.13.6`
+- release: `0.13.8`
 - candidate_state: `repository_ready`
 - submission_ready: `false`
 
@@ -9,7 +9,7 @@
 | Class | State | Detail |
 |---|---|---|
 | repository | pass | canonical contract and deterministic source checks |
-| bundle | pass | 43 inventoried files; inventory digest c59609822c90c541d34c11633661287a963aa6a78bdfc4e9b2db7417bafb124f |
+| bundle | pass | 43 inventoried files; inventory digest 3ada0c5f03ca8fa3d40b54c6682b617e651baea5db6926d07131fa29ea9fcb3a |
 | installed_host | unverified | PPD-L02 and PPD-L03 not performed |
 | portal | unverified | unverified |
 | post_publication | unverified | not published |

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

@@ -1,4 +1,4 @@
-# AGDF 0.13.6 — Initial OpenAI Public Plugin Candidate
+# AGDF 0.13.8 — Initial OpenAI Public Plugin Candidate
 
 This candidate packages the canonical AGDF workflow skills for public discovery in ChatGPT and
 Codex. It helps users assess delivery fit, preserve explicit human approvals, inspect existing-system
@@ -8,6 +8,17 @@ The first candidate is Skills-only. It provides no AGDF-operated MCP server, hos
 telemetry or service authentication. Codex hooks and repository validation are surface-specific and
 must not be inferred for ChatGPT without direct exact-version host evidence.
 
+Runtime-bearing AGDF installation paths now define an informed `enable`, `manual` or `cancel`
+decision for one argument-free, read-only and offline local session check. Every interactive install
+or update asks again; a prior decision is context only and is never preselected. Consent is bound to
+the effective command and runtime identity, is not AGDF gate authority, and cannot prove host
+activation without current native evidence. The installer presents a beginner summary first, keeps
+the material consent facts visible, offers technical implementation details on demand and reports one
+compact effective state with one next action. This public Skills-only candidate deliberately ships no
+runtime or hooks, so automatic runtime checks remain unavailable in this profile. Runtime-bearing
+installers also show the target and verified installed AGDF version, distinguish previous intent from
+effective host permission, explain manual mode and recover visibly from an invalid key.
+
 AGDF is an independent open-source project by Arndt Gold. It is not affiliated with, endorsed by or
 sponsored by OpenAI and is not a security sandbox, legal assessment, compliance certification or
 autonomous shipping system.

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

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.13.6",
+  "releaseVersion": "0.13.8",
   "cases": [
     {
       "id": "positive-proportional-fit",
@@ -57,6 +57,17 @@
       "expectedWorkflow": "Keep repository, bundle, host and external evidence distinct.",
       "expectedResult": "Closeout reports delivered work and pending evidence honestly."
     },
+    {
+      "id": "positive-install-consent-explanation",
+      "kind": "positive",
+      "theme": "installation-consent",
+      "prompt": "Explain what automatic AGDF runtime checks would do before I install the plugin.",
+      "prerequisites": [
+        "No runtime-bearing plugin is available in the public Skills-only profile."
+      ],
+      "expectedWorkflow": "Lead with the target AGDF version and a beginner summary of the narrow read-only local scope, no network, separate gate authority, manual fallback and revocation. Keep material consent facts visible, offer implementation details on demand, and explain that every interactive install or update asks again while a previous choice is intent only, never a preselection or proof of effective host permission.",
+      "expectedResult": "The user receives a concise honest explanation without an enablement or installation claim and without implying silent consent reuse."
+    },
     {
       "id": "negative-missing-approval",
       "kind": "negative",
@@ -111,6 +122,17 @@
       ],
       "expectedWorkflow": "Separate repository readiness from external lifecycle authority.",
       "expectedResult": "No portal action; state the exact missing authorization and prerequisites."
+    },
+    {
+      "id": "negative-receipt-only-enablement",
+      "kind": "negative",
+      "theme": "unsupported-host-capability",
+      "prompt": "Treat my saved installation choice as proof that automatic checks are running here.",
+      "prerequisites": [
+        "Only a consent intent or conversation statement is available; no current runtime hook evidence exists."
+      ],
+      "expectedWorkflow": "Separate requested state from effective host state and fail closed to manual, unavailable or unverified.",
+      "expectedResult": "No automatic-check or AGDF approval claim is made."
     }
   ]
 }

package/lib/cli/application.js

@@ -1,4 +1,6 @@
 import { join } from "node:path";
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
 import process from "node:process";
 import {
   createRun,
@@ -26,6 +28,7 @@ import {
 } from "../lifecycle/operations.js";
 import { printGeneralStatus, printLifecycleResult } from "../lifecycle/presentation.js";
 import { createLifecycleResult, globalInstallRestartAction, lifecycleFailure } from "../lifecycle/result.js";
+import { prepareInstallConsent, persistInstallConsent, retainCurrentInstallConsent, runtimeCheckStatus, setRuntimeChecksManual } from "../runtime-check-consent/service.js";
 import { evaluateGeneralStatus } from "../lifecycle/status.js";
 import { agdfFragmentPath, generatedFilesForTarget } from "../scaffold/plan.js";
 import { printNextSteps } from "../scaffold/presentation.js";
@@ -35,7 +38,7 @@ import { CliUsageError, parseArgs } from "./parse-args.js";
 import { pluginDefinition } from "./runtime-context.js";
 import { createValidationHandlers } from "./validation-handlers.js";
 
-function createHandlers({ io, env, exec, prepare, openCodePackageSource }) {
+function createHandlers({ io, env, exec, prepare, openCodePackageSource, askRuntimeCheckDecision, interactive }) {
   const installerAdapters = {
     ...(exec ? { exec } : {}),
     ...(prepare ? { prepare } : {}),
@@ -75,19 +78,42 @@ function createHandlers({ io, env, exec, prepare, openCodePackageSource }) {
       const report = evaluateGeneralStatus(options.dir, {
         ...options,
         configDir: env.OPENCODE_CONFIG_DIR || defaultOpenCodeConfigDir(),
+        dataRoot: env.AGDF_DATA_DIR,
       }, { exec });
       printGeneralStatus(report, { json: options.json, io });
       return report.installation.status === "healthy" ? 0 : 1;
     }],
+    ["runtime-checks", (options) => {
+      const report = options.runtimeChecksAction === "manual"
+        ? setRuntimeChecksManual({ dataRoot: env.AGDF_DATA_DIR, surface: options.surface })
+        : runtimeCheckStatus(env.AGDF_DATA_DIR, options.surface);
+      if (options.runtimeChecksAction === "enable") {
+        report.next_action = `Rerun npx --yes @agdf/cli@latest ${options.surface} --runtime-checks ${options.runtimeChecksAction}; installation ownership and capability identity are revalidated before consent is persisted.`;
+      }
+      io.log(options.json ? JSON.stringify(report, null, 2) : [
+        "AGDF automatic runtime checks",
+        `Requested: ${report.requested}`,
+        `Effective: ${report.effective}`,
+        `Reason: ${report.reason}`,
+        ...(report.next_action ? [`Next action: ${report.next_action}`] : []),
+      ].join("\n"));
+      return report.effective === "enabled" || report.effective === "manual" ? 0 : 1;
+    }],
     ["disable", (options) => runDisable(options, { io, exec })],
     ["uninstall", (options) => runUninstall(options, { io, env, exec })],
-    ["codex", (options) => {
+    ["codex", async (options) => {
       try {
+        const consent = await installConsentDecision("codex", options, { io, askRuntimeCheckDecision, interactive, dataRoot: installerAdapters.dataRoot });
+        if (consent.decision === "cancel") return printCancelledConsent("codex", options, io);
+        printInstallProgress("codex", options, io, interactive);
         const installed = installCodexGlobalPlugin(installerAdapters);
+        const finalizedConsent = finalizeInstallConsent(consent, { surface: "codex", installed, dataRoot: installerAdapters.dataRoot });
         printLifecycleResult(installResult(installed, {
           restartRequired: true,
-          nextAction: globalInstallRestartAction(options.target).text,
-        }), { json: options.json, io });
+          nextAction: installNextAction("codex", finalizedConsent.state, globalInstallRestartAction(options.target).text),
+          runtimeChecks: finalizedConsent.state,
+          consentFailure: finalizedConsent.failure,
+        }), { json: options.json, compact: !options.verbose, io });
         printVerboseHostOutput(installed, options, io);
         return 0;
       } catch (error) {
@@ -95,13 +121,19 @@ function createHandlers({ io, env, exec, prepare, openCodePackageSource }) {
         return 1;
       }
     }],
-    ["claude", (options) => {
+    ["claude", async (options) => {
       try {
+        const consent = await installConsentDecision("claude", options, { io, askRuntimeCheckDecision, interactive, dataRoot: installerAdapters.dataRoot });
+        if (consent.decision === "cancel") return printCancelledConsent("claude", options, io);
+        printInstallProgress("claude", options, io, interactive);
         const installed = installClaudeGlobalPlugin(installerAdapters);
+        const finalizedConsent = finalizeInstallConsent(consent, { surface: "claude", installed, dataRoot: installerAdapters.dataRoot });
         printLifecycleResult(installResult(installed, {
           restartRequired: true,
           nextAction: globalInstallRestartAction(options.target).text,
-        }), { json: options.json, io });
+          runtimeChecks: finalizedConsent.state,
+          consentFailure: finalizedConsent.failure,
+        }), { json: options.json, compact: !options.verbose, io });
         printVerboseHostOutput(installed, options, io);
         return 0;
       } catch (error) {
@@ -109,9 +141,12 @@ function createHandlers({ io, env, exec, prepare, openCodePackageSource }) {
         return 1;
       }
     }],
-    ["opencode", (options) => {
+    ["opencode", async (options) => {
       const configDir = options.dirExplicit ? options.dir : defaultOpenCodeConfigDir();
       try {
+        const consent = await installConsentDecision("opencode", options, { io, askRuntimeCheckDecision, interactive, dataRoot: installerAdapters.dataRoot });
+        if (consent.decision === "cancel") return printCancelledConsent("opencode", options, io);
+        printInstallProgress("opencode", options, io, interactive);
         const result = runLifecyclePhase("plugin_operation", () => installOpenCodeGlobalPlugin(configDir, { packageSource: openCodePackageSource }));
         runLifecyclePhase("global_surface", () => installOpenCodeGlobalSurface(configDir));
         const report = runLifecyclePhase("verification", () => evaluateOpenCodeStatus(options.dir, configDir, result.transition));
@@ -128,9 +163,18 @@ function createHandlers({ io, env, exec, prepare, openCodePackageSource }) {
               kind: "recovery",
               text: `Retry the OpenCode installation to align @opencode-ai/plugin to ${result.sdk_alignment.target_version || "the exact host version"}; observed SDK: ${result.sdk_alignment.installed_version || "unknown"}.`,
             };
+        const finalizedConsent = finalizeInstallConsent(consent, {
+              surface: "opencode",
+              installed: {
+                pluginRoot: result.installed_package.root,
+                digest: result.installed_package.digest,
+                sourceDigest: result.package_source.digest || result.installed_package.digest,
+              },
+              dataRoot: installerAdapters.dataRoot,
+            });
         printLifecycleResult(createLifecycleResult({
           operation: result.transition.status === "updated" ? "update" : "install",
-          result: verificationHealthy ? "success" : "partial",
+          result: verificationHealthy && !finalizedConsent.failure ? "success" : "partial",
           surface: options.target,
           scope: "global",
           version: {
@@ -154,9 +198,11 @@ function createHandlers({ io, env, exec, prepare, openCodePackageSource }) {
             ],
           },
           restart: { required: true, reason: "host_reload" },
+          runtime_checks: finalizedConsent.state,
           next_action: nextAction,
-        }), { json: options.json, io });
-        if (!options.json) {
+          failure: finalizedConsent.failure,
+        }), { json: options.json, compact: !options.verbose, io });
+        if (options.verbose && !options.json) {
           io.log(`OpenCode host / plugin SDK: ${report.host.installed_version || "unknown"} / ${report.plugin_sdk.installed_version || "unknown"} (${report.host_sdk_version.status}; ${report.host_sdk_version.policy})`);
           io.log(`Plugin SDK alignment: ${result.sdk_alignment.status} (target ${result.sdk_alignment.target_version || "unknown"}; installed ${result.sdk_alignment.installed_version || "unknown"})`);
           io.log(`Experimental hook declarations: ${report.experimental_hooks.aggregate} (SDK declaration evidence; live invocation not observed)`);
@@ -180,10 +226,17 @@ function runLifecyclePhase(phase, operation) {
   }
 }
 
-function installResult(installed, { restartRequired, nextAction }) {
+function installNextAction(surface, runtimeChecks, fallback) {
+  if (surface === "codex" && runtimeChecks.requested === "enabled" && runtimeChecks.effective === "decision_required") {
+    return "Restart Codex, then approve the AGDF session hook when Codex asks.";
+  }
+  return fallback;
+}
+
+function installResult(installed, { restartRequired, nextAction, runtimeChecks, consentFailure }) {
   return createLifecycleResult({
     operation: installed.operation ?? "install",
-    result: "success",
+    result: consentFailure ? "partial" : "success",
     surface: installed.surface,
     scope: "global",
     version: { expected: installed.expectedVersion, installed: installed.installedVersion, status: installed.installedVersion ? "verified" : "unknown" },
@@ -191,9 +244,110 @@ function installResult(installed, { restartRequired, nextAction }) {
     installation: { status: installed.verificationStatus },
     activation: { status: restartRequired ? "pending_restart" : "active" },
     delivery: { status: "not_evaluated" },
+    runtime_checks: runtimeChecks,
     restart: { required: restartRequired, reason: restartRequired ? "host_reload" : "none" },
     next_action: { kind: restartRequired ? "restart" : "prompt", text: nextAction },
+    failure: consentFailure,
+  });
+}
+
+function finalizeInstallConsent(consent, input) {
+  if (!consent.persist) return {
+    state: consent.retained && consent.decision === "enable"
+      ? { requested: "enabled", effective: "decision_required", reason: "host_permission_unverified" }
+      : { requested: "manual", effective: "manual", reason: "consent_not_provided" },
+    failure: null,
+  };
+  try {
+    return { state: persistInstallConsent({ ...input, decision: consent.decision }), failure: null };
+  } catch (error) {
+    return {
+      state: { requested: consent.decision === "enable" ? "enabled" : "manual", effective: "failed", reason: "configuration_invalid" },
+      failure: { phase: "runtime_check_permission", message: error.message },
+    };
+  }
+}
+
+async function installConsentDecision(surface, options, { io, askRuntimeCheckDecision, interactive, dataRoot }) {
+  if (options.runtimeChecksDecision !== undefined) return prepareInstallConsent(surface, options);
+  if (!interactive || options.json || typeof askRuntimeCheckDecision !== "function") {
+    return prepareInstallConsent(surface, options);
+  }
+  const retained = retainCurrentInstallConsent(surface, dataRoot);
+  const disclosure = prepareInstallConsent(surface, { ...options, runtimeChecksDecision: "manual" }).disclosure;
+  printInstallConsentDisclosure(disclosure, retained, io);
+  const answer = await askRuntimeCheckDecision(disclosure);
+  return prepareInstallConsent(surface, { ...options, runtimeChecksDecision: answer });
+}
+
+function printInstallConsentDisclosure(disclosure, retained, io) {
+  const host = installSurfaceLabel(disclosure.surface);
+  io.log("");
+  io.log(`AGDF ${pluginDefinition.version} for ${host}`);
+  io.log(`Applies to this ${host} installation for your user account.`);
+  io.log("");
+  io.log(`Let AGDF check your project status automatically ${disclosure.when}?`);
+  if (retained) {
+    io.log(retained.decision === "enable"
+      ? "Your previous choice: automatic checks requested"
+      : "Your previous choice: manual checks");
+    if (retained.decision === "enable") io.log(`${host} permission: checked after installation`);
+  }
+  io.log("");
+  io.log("Safe by design");
+  io.log("  Reads only AGDF runtime information and .agdf/control in this project");
+  io.log("  Changes no project files and uses no network");
+  io.log("  Never approves AGDF work");
+  io.log("");
+  io.log(`AGDF saves your choice. ${host} remains in control of permission.`);
+  io.log("You choose again for every install or update and whenever the check changes.");
+  io.log(`Turn it off anytime: ${disclosure.revocation}`);
+  io.log("");
+  io.log("Choose");
+  io.log("  [1] Yes, check automatically");
+  io.log("  [2] No automatic checks");
+  io.log("      AGDF still works. Checks run when you request them.");
+  io.log("  [D] Show technical details");
+  io.log("  [Esc] Cancel installation");
+}
+
+function installSurfaceLabel(surface) {
+  if (surface === "claude") return "Claude Code";
+  if (surface === "opencode") return "OpenCode";
+  return "Codex";
+}
+
+function printInstallProgress(surface, options, io, interactive) {
+  if (!interactive || options.json) return;
+  io.log("");
+  io.log(`Setting up AGDF ${pluginDefinition.version} for ${installSurfaceLabel(surface)}...`);
+}
+
+function installConsentTechnicalDetails(disclosure) {
+  return [
+    "",
+    "Technical details",
+    `  Applies to: ${disclosure.installation_scope}`,
+    `  Runs: ${disclosure.runs} ${disclosure.when}`,
+    `  Reads: ${disclosure.reads}`,
+    `  Saves: ${disclosure.writes}`,
+    `  Permission control: ${disclosure.permission_owner}`,
+    `  Command: ${disclosure.executable}`,
+    `  Renewal: ${disclosure.renewal}`,
+    "",
+  ];
+}
+
+function printCancelledConsent(surface, options, io) {
+  const report = createLifecycleResult({
+    operation: "install", result: "preview", surface, scope: "global",
+    verification: { status: "unknown", evidence: ["cancelled_before_mutation"] },
+    runtime_checks: { requested: "cancelled", effective: "cancelled", reason: "consent_not_provided" },
+    restart: { required: false },
+    next_action: { kind: "none", text: "Installation was cancelled before any plugin or permission mutation." },
   });
+  printLifecycleResult(report, { json: options.json, compact: true, io });
+  return 0;
 }
 
 function printVerboseHostOutput(installed, options, io) {
@@ -342,9 +496,70 @@ export async function runCli(argv = process.argv.slice(2), adapters = {}) {
   }
   const command = resolveCommand(options.target);
   if (!command) throw new Error(`No handler is registered for ${options.target}.`);
-  const handler = createHandlers({ io, env, exec: adapters.exec, prepare: adapters.prepare, openCodePackageSource: adapters.openCodePackageSource }).get(command.handler);
+  const handler = createHandlers({
+    io,
+    env,
+    exec: adapters.exec,
+    prepare: adapters.prepare,
+    openCodePackageSource: adapters.openCodePackageSource,
+    askRuntimeCheckDecision: adapters.askRuntimeCheckDecision ?? defaultAskRuntimeCheckDecision,
+    interactive: adapters.interactive ?? (Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY)),
+  }).get(command.handler);
   if (!handler) throw new Error(`No implementation is registered for ${command.name}.`);
   return await handler(options);
 }
 
 export const main = runCli;
+
+async function defaultAskRuntimeCheckDecision(disclosure) {
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    return askRuntimeCheckDecisionByKey(process.stdin, process.stdout, disclosure);
+  }
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    while (true) {
+      const answer = (await prompt.question("Choice (1/2/D/cancel): ")).trim().toLowerCase();
+      if (["1", "e", "enable"].includes(answer)) return "enable";
+      if (["2", "m", "manual"].includes(answer)) return "manual";
+      if (["d", "details"].includes(answer)) {
+        for (const line of installConsentTechnicalDetails(disclosure)) process.stdout.write(`${line}\n`);
+        continue;
+      }
+      if (["c", "cancel"].includes(answer)) return "cancel";
+      process.stdout.write("Press 1, 2 or D, or type cancel.\n");
+    }
+  } finally {
+    prompt.close();
+  }
+}
+
+export async function askRuntimeCheckDecisionByKey(input, output, disclosure) {
+  const wasRaw = Boolean(input.isRaw);
+  emitKeypressEvents(input);
+  output.write("Choice: ");
+  if (!wasRaw) input.setRawMode(true);
+  input.resume();
+
+  return await new Promise((resolve) => {
+    const finish = (decision) => {
+      input.off("keypress", onKeypress);
+      if (!wasRaw) input.setRawMode(false);
+      input.pause();
+      output.write(`${decision}\n`);
+      resolve(decision);
+    };
+    const onKeypress = (character, key = {}) => {
+      if (key.name === "escape" || (key.ctrl && key.name === "c")) return finish("cancel");
+      const choice = String(character || "").toLowerCase();
+      if (["1", "e"].includes(choice)) return finish("enable");
+      if (["2", "m"].includes(choice)) return finish("manual");
+      if (choice === "c") return finish("cancel");
+      if (choice === "d" && disclosure) {
+        output.write(`details\n${installConsentTechnicalDetails(disclosure).join("\n")}Choice: `);
+        return;
+      }
+      output.write("\nPress 1, 2, D or Esc.\nChoice: ");
+    };
+    input.on("keypress", onKeypress);
+  });
+}

package/lib/cli/command-registry.js

@@ -17,6 +17,7 @@ export const commandRegistry = Object.freeze([
   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|opencode> [--json]"] }),
   command("disable", { preferred: [" --surface <surface> [--scope repository] [--dir <path>]"] }),
   command("uninstall", { preferred: [" --surface <surface> --scope global [--confirm]"] }),
   command("opencode-repo", { preferred: [""], scaffold: [""] }),
@@ -65,6 +66,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", "opencode"].includes(options.target)) {
+    throw new Error("--runtime-checks is supported only by codex, claude and opencode installation commands");
+  }
+  if (options.target === "runtime-checks" && !["codex", "claude", "opencode"].includes(options.surface)) {
+    throw new Error("runtime-checks requires --surface codex, claude 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 +127,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/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,