create-agdf 0.20.1 → 0.30.0

package/lib/cli/validation-handlers.js

@@ -1,13 +1,11 @@
-import { recordGateApprovalCommand, resolveControlCommandTarget } from "../control-command.js";
-import { COOPERATIVE_ASSURANCE } from "#agdf-core/control-state/approval-command-contract.js";
+import { executeRunAlias } from './run-command-aliases.js';
+import { executeProjectRead } from './project-read-command.js';
+import { localePack } from '#agdf-core/interaction-presentation.js';
+import { renderCodexDocument } from './codex-document-command.js';
 import { readFileSync, lstatSync, openSync, fstatSync, closeSync, constants } from "node:fs";
 import { commandGroupRoutes } from './command-registry.js';
 import { RUN_COMMAND_LIMITS } from '#agdf-core/control-state/run-command-contract.js';
 import { executeControlMaintenance } from "./control-maintenance-command.js";
-import { createRun } from "#agdf-core/control-state/run-state-repository.js";
-import { extractField } from "#agdf-core/control-evaluation/verified-change.js";
-import { ARTEFACT_TEMPLATE_IDS, resolveArtefactTemplatePath } from "#agdf-core/resources/artefact-templates.js";
-import { prepareRunPresentation } from "#agdf-core/control-state/run-presentation.js";
 import {
   buildStatusCard,
   evaluateGateCheck,
@@ -19,19 +17,19 @@ import { evaluateDeliveryMap, printDeliveryMapReport } from "#agdf-core/control-
 import { evaluateDoctor, printDoctorReport } from "#agdf-core/control-evaluation/doctor.js";
 import { executeDeliveryPathSearch } from "./delivery-path-search-command.js";
 import { resolveTaskTarget } from "#agdf-core/task-target-resolution.js";
-import { renderSkillDispatchRecovery, renderTaskTargetOrientation, renderSourceRevision } from "#agdf-core/interaction-presentation.js";
+import { renderSkillDispatchRecovery, renderTaskTargetOrientation, renderSourceRevision, renderRunInventory } from "#agdf-core/interaction-presentation.js";
+import { readRunInventory } from "#agdf-core/control-state/run-inventory-reader.js";
+import { readWorkInventory } from '#agdf-core/control-state/planned-inventory.js';
+import { readControlLayout, CURRENT_LAYOUT } from '#agdf-core/control-state/control-layout.js';
+import { executePlannedCli } from './planned-command.js';
 import { interactionLocales, pluginDefinition } from "./runtime-context.js";
 import { serializeSkillDispatchResult } from "#agdf-core/skill-dispatch/contract.js";
 import { createCoreServices } from "#agdf-core";
 import { resources } from "../runtime/control-context.js";
-import { approveRunGate, recordRunRevision } from "#agdf-core/control-state/run-recording.js";
-import { reopenPrdRevision, previewSourceRevision, applySourceRevision, inspectSourceRevision, recoverSourceRevision } from "#agdf-core/control-state/run-revision.js";
 import { readRuntimeContract, readSkillRuntimeContracts } from "./contract-command.js";
-import { recordRunStep } from "#agdf-core/control-state/run-steps.js";
-import { policyForRunContent } from "#agdf-core/control-evaluation/run-step-policy.js";
 import { cliGitObservation } from "../control-evaluation/git-observation.js";
 import { resolveRepositoryContext } from "../repository-context.js";
-import { applyRunRecovery, inspectRunRecovery, previewRunRecovery } from "../control-state/run-recovery.js";
+import { resolveConfiguredChatLanguage } from "#agdf-core/resources/context.js";
 
 const evaluateDoctorWithCliGit = (target, selection) => evaluateDoctor(target, selection, cliGitObservation);
 const evaluateGateWithCliGit = (target, selection) => evaluateGateCheck(target, selection, cliGitObservation);
@@ -47,6 +45,9 @@ export function createValidationHandlers(io = console) {
     readSkillRuntimeContracts,
   } }).dispatch;
   return new Map([
+    ...['project-state', 'operation-status'].map(name => [name, options => executeProjectRead(options, io)]),
+    ['render-document', options => renderCodexDocument(options)],
+    ...['run-create', 'run-present', 'run-approve', 'run-step', 'run-revise', 'run-close'].map(name => [name, options => executeRunAlias(options, io)]),
     ...Object.entries(commandGroupRoutes).map(([route, group]) => [route, options => {
       let fd;
       try {
@@ -58,39 +59,14 @@ export function createValidationHandlers(io = console) {
         const bytes = readFileSync(fd);
         if (bytes.length > RUN_COMMAND_LIMITS.input_bytes) throw Error('command_file_invalid');
         const input = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
-        const result = createCoreServices({ resources }).command(group, input);
+        const result = createCoreServices({ resources, observers: { gitObservation: cliGitObservation } }).command(group, input);
         io.log(JSON.stringify(result));
         return ['accepted', 'already_applied'].includes(result.outcome) ? 0 : 2;
       } catch (error) { io.error(error.message); return 1; }
       finally { if (fd !== undefined) closeSync(fd); }
     }]),
     ["control-maintenance", (options) => executeControlMaintenance(options, io)],
-    ["run-create", (options) => {
-      try {
-        const path = createRun(options.dir, options.runId);
-        const revisionId = extractField(readFileSync(path, "utf8"), "revision_id");
-        io.log(path);
-        io.log(`revision_id: ${revisionId}`);
-        // The plugin-owned template is the only authoring source; repository scaffold copies are
-        // derived references. Run creation itself never fails on template availability.
-        let urTemplate = null;
-        try { urTemplate = resolveArtefactTemplatePath(ARTEFACT_TEMPLATE_IDS.UR); } catch {}
-        const templateSource = urTemplate
-          ? `the plugin-owned UR template at ${urTemplate}`
-          : "the plugin-owned UR template supplied as template_path by the bound ur-definition dispatch";
-        io.log(`Next: write .agdf/control/artefacts/${options.runId}/UR.md from ${templateSource}, then record it with run-step --run ${options.runId} --revision ${revisionId} --step ur --title "<short requirement title>".`);
-        return 0;
-      } catch (error) {
-        io.error(error instanceof Error ? error.message : String(error));
-        return 1;
-      }
-    }],
-    ["run-present", (options) => {
-      const result = prepareRunPresentation(options.dir, { runId: options.runId, gate: options.gate,
-        revisionId: options.revisionId, language: options.language?.chat_language }, { evaluateGateCheck: evaluateGateWithCliGit });
-      io.log(JSON.stringify(result, null, 2));
-      return result.outcome === "prepared" ? 0 : 2;
-    }],
+    ['planned', options => executePlannedCli(options, io)],
     ["target-check", (options) => {
       const report = resolveTaskTargetWithCliGit({
         targetSource: options.targetSource,
@@ -138,7 +114,13 @@ export function createValidationHandlers(io = console) {
     }],
     ["doctor", (options) => {
       const report = evaluateDoctorWithCliGit(options.dir, options);
-      printDoctorReport(report, options.json, io);
+      let emptyInventoryText;
+      if (report.empty_inventory && !options.json) {
+        const language = options.languageExplicit ? options.language.chat_language : resolveConfiguredChatLanguage(options.dir);
+        emptyInventoryText = localePack(interactionLocales, language).doctorEmptyInventory?.policyDescription
+          .replace('{policy}', String(report.empty_inventory.allow_no_active_runs));
+      }
+      printDoctorReport(report, options.json, io, { emptyInventoryText });
       return report.status === "block" ? 2 : 0;
     }],
     ["gate-check", (options) => {
@@ -154,6 +136,17 @@ export function createValidationHandlers(io = console) {
       if (presentationRendered === false) return 2;
       return report.status === "blocked" ? 2 : 0;
     }],
+    ["inventory", (options) => {
+      const language = options.languageExplicit ? options.language?.chat_language : resolveConfiguredChatLanguage(options.dir);
+      if (readControlLayout(options.dir).layout === CURRENT_LAYOUT) {
+        const inventory = readWorkInventory(options.dir, { language });
+        io.log(options.json ? JSON.stringify(inventory, null, 2) : inventory.entries.map(row => `${row.kind}: ${row.title} · ${row.coverage}`).join('\n'));
+        return inventory.state === 'unavailable' ? 2 : 0;
+      }
+      const inventory = readRunInventory(options.dir, { language });
+      io.log(options.json ? JSON.stringify(inventory, null, 2) : renderRunInventory(inventory, interactionLocales, language).markdown);
+      return 0;
+    }],
     ["delivery-map", (options) => {
       const report = evaluateDeliveryMap(options.dir, options, deliveryMapDependencies);
       printDeliveryMapReport(report, options.json, io);
@@ -168,69 +161,6 @@ export function createValidationHandlers(io = console) {
       io.log(options.json ? JSON.stringify({ module: result.module, content: result.content }) : result.content.replace(/\n$/u, ""));
       return 0;
     }],
-    ["run-update", (options) => {
-      const result = recordRunRevision(options.dir, { runId: options.runId, revisionId: options.revisionId });
-      io.log(JSON.stringify(result, null, 2));
-      return result.outcome === "rejected" ? 2 : 0;
-    }],
-    ["run-revise", (options) => {
-      const operation = { preview: previewSourceRevision, apply: applySourceRevision, inspect: inspectSourceRevision, recover: recoverSourceRevision }[options.revisionMode] ?? reopenPrdRevision;
-      const result = operation(options.dir, { runId: options.runId, revisionId: options.revisionId,
-        operationId: options.operationId, sourceGate: options.sourceGate, evidence: options.stepFields?.evidence, previewDigest: options.previewDigest });
-      io.log(options.revisionMode && !options.json ? renderSourceRevision(result, interactionLocales, options.language.chat_language,
-        { ...options, target: options.dir }).markdown : JSON.stringify(result, null, 2));
-      return ["rejected", "recovery_required"].includes(result.outcome) ? 2 : 0;
-    }],
-    ["run-step", (options) => {
-      const result = recordRunStep(options.dir, {
-        runId: options.runId,
-        revisionId: options.revisionId,
-        step: options.runStep,
-        ...(options.gate ? { gate: options.gate } : {}),
-        ...options.stepFields,
-      }, { policy: policyForRunContent });
-      io.log(JSON.stringify(result, null, 2));
-      return result.outcome === "rejected" ? 2 : 0;
-    }],
-    ["run-approve", (options) => {
-      let result;
-      if (options.assurance !== undefined && options.assurance !== "cooperative_local") {
-        result = { schema_version: "1", outcome: "rejected", run_id: options.runId,
-          reason: "unsupported_authority", assurance: COOPERATIVE_ASSURANCE };
-      } else if (options.operationId !== undefined) {
-        result = recordGateApprovalCommand(options.dir, {
-          schema_version: "1", action: "record_gate_approval",
-          target_id: resolveControlCommandTarget(options.dir).target_id, run_id: options.runId,
-          gate: options.gate, expected_revision_id: options.revisionId,
-          presentation_id: options.presentationId, response: options.response,
-          operation_id: options.operationId, assurance: options.assurance ?? "cooperative_local",
-        });
-      } else result = { ...approveRunGate(options.dir, {
-        runId: options.runId,
-        gate: options.gate,
-        revisionId: options.revisionId,
-        response: options.response,
-        presentationId: options.presentationId,
-      }, { evaluateGateCheck: evaluateGateWithCliGit }), assurance: COOPERATIVE_ASSURANCE };
-      io.log(JSON.stringify(result, null, 2));
-      return ["approved", "accepted", "already_applied"].includes(result.outcome) ? 0 : 2;
-    }],
-    ["run-recovery", (options) => {
-      try {
-        const result = options.recoveryAction === "inspect"
-          ? inspectRunRecovery(options.dir, options.runId)
-          : options.recoveryAction === "preview"
-            ? previewRunRecovery(options.dir, options.runId)
-            : applyRunRecovery(options.dir, { runId: options.runId,
-              previewId: options.recoveryPreviewId, confirmation: options.recoveryConfirmation });
-        io.log(JSON.stringify(result, null, 2));
-        return 0;
-      } catch (error) {
-        io.log(JSON.stringify({ schema_version: "1", outcome: "blocked", run_id: options.runId,
-          action: options.recoveryAction, reason: error instanceof Error ? error.message : String(error) }, null, 2));
-        return 2;
-      }
-    }],
     ["delivery-path-search", async (options) => {
       try {
         const result = await executeDeliveryPathSearch(options, io);

package/lib/control-evaluation/git-observation.js

@@ -1,11 +1,12 @@
 import { execFileSync } from "node:child_process";
+const readOnlyOptions = ['--no-optional-locks', '-c', 'core.fsmonitor=false'];
 
 export function gitPathList(targetDir, args, exec = execFileSync) {
   try {
-    return exec("git", args, { cwd: targetDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })
-      .split("\n")
-      .map((item) => item.trim())
-      .filter(Boolean);
+    if (![JSON.stringify(['diff', 'HEAD', '--name-only']), JSON.stringify(['ls-files', '--others', '--exclude-standard'])].includes(JSON.stringify(args))) return null;
+    const fixed = args[0] === 'diff' ? ['diff', '--no-ext-diff', '--no-textconv', ...args.slice(1)] : args;
+    const bytes = exec("git", [...readOnlyOptions, ...fixed, '-z'], { cwd: targetDir, encoding: 'buffer', stdio: ["ignore", "pipe", "ignore"], timeout: 3000, maxBuffer: 2 * 1024 * 1024 });
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes).split('\0').filter(item => item.length > 0);
   } catch {
     return null;
   }
@@ -13,7 +14,8 @@ export function gitPathList(targetDir, args, exec = execFileSync) {
 
 export function gitValue(targetDir, args, exec = execFileSync) {
   try {
-    return exec("git", args, { cwd: targetDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (![JSON.stringify(['rev-parse', 'HEAD']), JSON.stringify(['rev-parse', '--show-toplevel'])].includes(JSON.stringify(args))) return null;
+    return exec("git", [...readOnlyOptions, ...args], { cwd: targetDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000, maxBuffer: 2 * 1024 * 1024 }).trim();
   } catch {
     return null;
   }

package/lib/control-maintenance/startup.js

@@ -20,6 +20,6 @@ export function inspectStartupCompatibility({ target, executable, validator, env
 }
 
 export function startupMaintenanceInvocation(facts, { executable, validator, language = "en" }) {
-  if (!["migration_required", "repair_required", "unavailable"].includes(facts.status)) return null;
-  return { executable, argv: [validator, "control-maintenance", "--dir", facts.target, "--guided", "--language", language], authorizes: false };
+  if (!["unsupported", "repair_required", "unavailable"].includes(facts.status)) return null;
+  return { executable, argv: [validator, "control-maintenance", "--dir", facts.target, "--language", language], authorizes: false };
 }

package/lib/host-adapters/codex/plugin.js

@@ -1,13 +1,14 @@
 import process from "node:process";
 import { inspectPluginList } from "../../installers/plugin-command.js";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from 'node:os';
 import { join } from "node:path";
 import { inspectGeneratedRepositoryMarketplace } from "#agdf-core/runtime/plugin-provenance.js";
 import { execHostFileSync } from "../../host-command.js";
 import { pluginDefinition } from "../../cli/runtime-context.js";
 import { historicalEvidenceEntries, rollbackMarketplaceFilesystem, captureOptions, runPluginPhase, lifecycleAdapterError, pluginVersionFromList, versionMismatchMessage, recoveryAttempt } from "../../installers/plugin-command.js";
 import { CODEX_REGISTRATION_REVISION, isCodexLocalInstallVersion } from "./identity.js";
-import { classifyMarketplaceList, inspectLocalMarketplaceProjection, prepareLocalMarketplace, inspectCodexOwnedManifestRepair } from "../../installers/local-marketplace.js";
+import { classifyMarketplaceList, inspectLocalMarketplaceProjection, prepareLocalMarketplace, inspectCodexOwnedManifestRepair, inspectPlanningMarketplace } from "../../installers/local-marketplace.js";
 import { migrateLegacyCodexMcpRegistration, prepareCodexPluginMcp } from "./plugin-mcp.js";
 import { ownedFileSnapshot } from "../../lifecycle/owned-mutation.js";
 import { inspectCodexCockpitAdmission, inspectCodexSetup } from '../../mcp-lifecycle/adapters/codex.js';
@@ -24,7 +25,10 @@ export function installCodexGlobalPlugin({
   migrateMcp = migrateLegacyCodexMcpRegistration,
   prepareMcp = prepareCodexPluginMcp,
   target,
+  packageSelection = 'core',
 } = {}) {
+  if (packageSelection === 'planning') return installCodexPlanningPlugin({ exec, prepare, dataRoot, env });
+  if (packageSelection !== 'core') throw Error('AGDF_PACKAGE_SELECTION_INVALID');
   const expectedVersion = pluginDefinition.version;
   const nativeOutput = [];
   if (target) target = realpathSync(target);
@@ -104,6 +108,49 @@ export function installCodexGlobalPlugin({
   }
 }
 
+function installCodexPlanningPlugin({ exec, prepare, dataRoot, env }) {
+  const list = runPluginPhase(exec, 'codex', ['plugin', 'list'], 'verification', { ...captureOptions(), maxBuffer: CODEX_PLUGIN_LIST_MAX_BUFFER });
+  const coreSelector = ['agdf@agdf-repo', 'agdf@agdf'].find(selector => pluginVersionFromList(list, selector));
+  const coreVersion = coreSelector && pluginVersionFromList(list, coreSelector);
+  if (!coreVersion || !/^[0-9A-Za-z.+-]+$/u.test(coreVersion)) throw Error('AGDF_PLANNING_CORE_REQUIRED');
+  const marketplace = coreSelector.split('@')[1];
+  const coreRoot = join(env.CODEX_HOME || join(homedir(), '.codex'), 'plugins/cache', marketplace, 'agdf', coreVersion);
+  let capability;
+  try { capability = JSON.parse(readFileSync(join(coreRoot, 'meta/agdf-plugin.definition.json'), 'utf8')).planning; } catch {}
+  if (capability?.schema !== 'planned-ur-v1' || capability.protocol_version !== 1 || capability.authoring_owner !== 'ur-definition') throw Error('AGDF_PLANNING_COMPATIBLE_CORE_REQUIRED');
+  const transaction = prepare({ packageSelection: 'planning', expectedVersion: pluginDefinition.version, ...(dataRoot ? { dataRoot } : {}) });
+  const output = runPluginPhase(exec, 'codex', ['plugin', 'marketplace', 'list', '--json'], 'marketplace', captureOptions());
+  const entries = JSON.parse(output)?.marketplaces;
+  if (!Array.isArray(entries)) throw Error('AGDF_PLANNING_MARKETPLACE_UNKNOWN');
+  const matches = entries.filter(entry => entry?.name === 'agdf-planning');
+  if (matches.length > 1) throw Error('AGDF_PLANNING_MARKETPLACE_UNKNOWN');
+  const previous = matches[0], previousRoot = previous?.marketplaceSource?.source ?? previous?.source?.source ?? previous?.marketplaceSource?.path ?? previous?.source?.path ?? previous?.path;
+  if (previous) {
+    if (typeof previousRoot !== 'string') throw Error('AGDF_PLANNING_MARKETPLACE_UNKNOWN');
+    inspectPlanningMarketplace(previousRoot); // Foreign catalogs are never replaced.
+  }
+  let added = false, removed = false;
+  try {
+    if (previousRoot !== transaction.root) {
+      if (previousRoot) { runPluginPhase(exec, 'codex', ['plugin', 'marketplace', 'remove', 'agdf-planning', '--json'], 'marketplace', captureOptions()); removed = true; }
+      runPluginPhase(exec, 'codex', ['plugin', 'marketplace', 'add', transaction.root, '--json'], 'marketplace', captureOptions()); added = true;
+    }
+    runPluginPhase(exec, 'codex', ['plugin', 'add', 'agdf-planning@agdf-planning', '--json'], 'plugin_operation', captureOptions());
+    const observed = runPluginPhase(exec, 'codex', ['plugin', 'list'], 'verification', { ...captureOptions(), maxBuffer: CODEX_PLUGIN_LIST_MAX_BUFFER });
+    const installedVersion = pluginVersionFromList(observed, 'agdf-planning@agdf-planning');
+    if (installedVersion !== transaction.codexInstallVersion) throw Error('AGDF_PLANNING_VERSION_UNCONFIRMED');
+    return { surface: 'codex', operation: 'install', expectedVersion: transaction.codexInstallVersion, installedVersion,
+      verificationStatus: 'configured_pending_restart', pluginRoot: transaction.pluginRoot, digest: transaction.digest, sourceDigest: transaction.sourceDigest,
+      runtimeDigest: null, evidence: ['optional_planning_only', 'compatible_core_metadata', 'codex plugin list', 'fresh_session_capability_check_required'], nativeOutput: [] };
+  } catch (error) {
+    const evidence = [], recovery = recoveryAttempt(exec, 'codex', evidence);
+    if (added) recovery(['plugin', 'marketplace', 'remove', 'agdf-planning', '--json']);
+    if (removed) recovery(['plugin', 'marketplace', 'add', previousRoot, '--json']);
+    error.recovery = evidence;
+    throw error;
+  }
+}
+
 function migrateMarketplace({ exec, output, root, nativeOutput, migration, refreshOwnedLocal = false }) {
   const classification = classifyMarketplaceList("codex", output, root);
   Object.assign(migration, classification);

package/lib/install-setup/contract.js

@@ -2,7 +2,7 @@ import { INSTALL_SETUP_STATES, INSTALL_ACTIONS, INSTALL_FAILURE_PHASES, INSTALL_
 import { isAbsolute } from "node:path";
 import { assertLifecycleResult } from "../lifecycle/result.js";
 import { mcpCapabilityProfileContract } from "../mcp-lifecycle/profile.js";
-import { assertControlMigration, uncheckedControl } from "./control-migration.js";
+import { assertControlCompatibility, uncheckedControl } from "./control-compatibility.js";
 
 const SURFACES = new Set(mcpCapabilityProfileContract.surfaces);
 const SETUP_REQUESTS = new Set(["plugin_only", "full", "cancel"]);
@@ -130,7 +130,7 @@ export function deriveInstallSetupState({ setup_request: setupRequest, surface,
   if (!pluginVerified(plugin)) return "failed";
   if (failure?.phase === "runtime_check_permission") return "partial";
   if (!failure && control?.status === "repair_required") return "control_repair_required";
-  if (!failure && control?.status === "migration_required") return "control_migration_required";
+  if (!failure && control?.status === "unsupported") return "control_unsupported";
   const state = mcpState(mcp);
   if (setupRequest === "plugin_only") {
     if (state === "plugin_managed" && !failure && codexHookReviewPending(surface, runtimeChecks)) {
@@ -165,7 +165,7 @@ export function createInstallSetupPreflight(input = {}) {
   const pluginConfiguration = input.plugin_configuration ?? null;
   const invocationDirectorySource = input.invocation_directory_source ?? "none";
   const fullBlockReason = input.full_block_reason ?? "none";
-  const control = assertControlMigration(input.control ?? uncheckedControl());
+  const control = assertControlCompatibility(input.control ?? uncheckedControl());
   const scopeStateValid = (state) => plainObject(state)
     && Object.keys(state).every((key) => [
       "status", "capability", "selected_status", "effective_source", "registration_path",
@@ -236,7 +236,7 @@ export function createInstallSetupResult(input = {}) {
   const requestedScope = input.requested_scope ?? null;
   const effectiveScope = input.effective_scope ?? null;
   const invocationDirectorySource = input.invocation_directory_source ?? "none";
-  const control = assertControlMigration(input.control ?? uncheckedControl());
+  const control = assertControlCompatibility(input.control ?? uncheckedControl());
   if (!SETUP_REQUESTS.has(input.setup_request) || !SURFACES.has(input.surface)
       || !(target === null || (typeof target === "string" && isAbsolute(target)))
       || !TARGET_SOURCES.has(input.target_source)

package/lib/install-setup/{control-migration.js → control-compatibility.js}

@@ -1,5 +1,4 @@
-export { CONTROL_MIGRATION_STATUSES, uncheckedControl, inspectControlMigration, assertControlMigration } from "#agdf-core/control-maintenance/compatibility.js";
-export { migrateInstallationControl } from "#agdf-core/control-maintenance/migration.js";
+export { CONTROL_COMPATIBILITY_STATUSES, uncheckedControl, inspectControlCompatibility, assertControlCompatibility } from "#agdf-core/control-maintenance/compatibility.js";
 
 export function installationControlTarget(options) {
   if (options.controlDir) return { root: options.controlDir, writable: true };

package/lib/install-setup/interaction.js

@@ -1,4 +1,3 @@
-export { selectControlMigration, promptControlMigration, selectControlRepair, promptControlRepair } from "../control-maintenance/interaction.js";
 import { createInterface } from "node:readline/promises";
 import process from "node:process";
 import { interactionLocales } from "../cli/runtime-context.js";

package/lib/install-setup/presentation.js

@@ -1,5 +1,4 @@
-export { renderControlMigration, renderControlMigrationDecision, renderControlRepairOffer, renderControlRepairPlan } from "#agdf-core/control-maintenance/presentation.js";
-import { renderControlMigration } from "#agdf-core/control-maintenance/presentation.js";
+import { renderControlCompatibility } from "#agdf-core/control-maintenance/presentation.js";
 import { interactionLocales } from "../cli/runtime-context.js";
 import { localePack } from "#agdf-core/interaction-presentation.js";
 
@@ -235,7 +234,7 @@ export function renderInstallSetupPreflight(preflight, { registry = interactionL
     `${labels.packageAcquisition}: ${preflight.package_acquisition_required ? value.required : value.not_required}`,
     `${labels.removal}: ${preflight.removal_overview}`,
     `${labels.authorizes}: ${preflight.authorizes}`,
-    renderControlMigration(preflight.control, { registry, language }),
+    renderControlCompatibility(preflight.control, { registry, language }),
     "",
   ];
   for (const option of options) {
@@ -326,7 +325,7 @@ export function renderInstallSetupText(report, { registry = interactionLocales,
     `${labels.failure}: ${failure}`,
     `${labels.authorizes}: ${report.authorizes}`,
     `${labels.nextAction}: ${projected.next_action.text}`,
-    renderControlMigration(report.control, { registry, language, details: verbose }),
+    renderControlCompatibility(report.control, { registry, language, details: verbose }),
   ].join("\n");
 }
 

package/lib/install-setup/service.js

@@ -4,8 +4,7 @@ import { inspectGlobalInstallationStatus } from "../lifecycle/status.js";
 import { runMcpLifecycle } from "../mcp-lifecycle/service.js";
 import { pluginDefinition } from "../cli/runtime-context.js";
 import { codexHookReviewPending, codexPendingHookAction, createInstallSetupPreflight, createInstallSetupResult } from "./contract.js";
-import { inspectControlMigration, installationControlTarget, migrateInstallationControl } from "./control-migration.js";
-import { repairInstallationControl } from "./control-repair.js";
+import { inspectControlCompatibility, installationControlTarget } from "./control-compatibility.js";
 
 const SURFACES = new Set(["codex", "claude", "copilot", "opencode"]);
 const SCOPE_DECISIONS = new Set(["project", "user", "back", "cancel"]);
@@ -170,7 +169,7 @@ export function inspectInstallSetup({ options, interactive = false, env = proces
     removal_overview: `npx --yes @agdf/cli@latest uninstall --surface ${options.target} --scope global`,
     full_available: fullAvailable,
     full_block_reason: blockReason,
-    control: inspectControlMigration(installationControlTarget(options).root),
+    control: inspectControlCompatibility(installationControlTarget(options).root),
     authorizes: false,
   });
   PREFLIGHT_MCP_REPORTS.set(preflight, Object.freeze({ ...reports }));
@@ -289,8 +288,8 @@ function completedResult({ selection, selectedScope, preflight, pluginReport, ru
     nextAction = codexPendingHookAction(runtimeChecks?.state ?? runtimeChecks);
   }
   const target = full ? preflight.target : null;
-  if (!failure && control?.status === "migration_required") nextAction = "migrate_control";
-  if (!failure && control?.status === "repair_required") nextAction = "repair_control";
+  if (!failure && control?.status === "unsupported") nextAction = "inspect_control";
+  if (!failure && control?.status === "repair_required") nextAction = "inspect_control";
   const targetSource = full
     ? preflight.target_source === "interactive_invocation_cwd_proposal" ? "interactive_invocation_cwd_selection" : preflight.target_source
     : "none";
@@ -327,9 +326,6 @@ export async function runInstallSetup({ options, interactive = false, env = proc
   installPlugin,
   createPluginFailure,
   finalizeRuntimeChecks,
-  confirmControlMigration,
-  chooseControlRepair,
-  confirmControlRepair,
 } = {}) {
   if (!SURFACES.has(options?.target) || typeof installPlugin !== "function") {
     throw new Error("AGDF_INSTALL_SETUP_INPUT_INVALID");
@@ -426,16 +422,7 @@ export async function runInstallSetup({ options, interactive = false, env = proc
     });
   }
   const controlTarget = installationControlTarget(options);
-  const batchConfirmation = effectiveInteractive ? confirmControlMigration : undefined;
-  let control = pluginHealthy(pluginReport)
-    ? await migrateInstallationControl(controlTarget.root, {
-      mode: options.controlMigration === "inspect" || (!controlTarget.writable && !batchConfirmation) ? "inspect" : "safe",
-      confirmMigration: batchConfirmation,
-    })
-    : preflight.control;
-  if (pluginHealthy(pluginReport) && effectiveInteractive && options.controlMigration !== "inspect") {
-    control = await repairInstallationControl(control, { chooseRepair: chooseControlRepair, confirmRepair: confirmControlRepair });
-  }
+  const control = pluginHealthy(pluginReport) ? inspectControlCompatibility(controlTarget.root) : preflight.control;
   const report = completedResult({ selection, selectedScope, preflight, pluginReport, runtimeChecks, mcpReport, control });
   return Object.freeze({ report, preflight, plugin_payload: pluginPayload ?? null });
 }