create-agdf 0.14.5 → 0.20.0

package/lib/lifecycle/operations.js

@@ -1,28 +1,28 @@
+import process from "node:process";
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { execHostFileSync } from "../host-command.js";
+import { mkdirSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { pluginDefinition } from "../cli/runtime-context.js";
 import {
   applyCopilotRepositoryDisable,
   planCopilotRepositoryDisable,
   verifyCopilotRepositoryDisabled,
 } from "../installers/copilot-settings.js";
-import { evaluateOpenCodeStatus, openCodeNpmInvocation } from "../installers/opencode.js";
+import {
+  evaluateOpenCodeGlobalStatus as inspectOpenCodeGlobalStatus,
+  planOpenCodeGlobalUninstall,
+  verifyOpenCodeGlobalUninstall,
+} from "../installers/opencode.js";
 import { inspectPluginSurface } from "../installers/plugin-installers.js";
-import { inspectGeneratedRepositoryMarketplace } from "../runtime/plugin-provenance.js";
-
-const CODEX_DISABLE_MARKER = "# AGDF-OWNED-REPOSITORY-PLUGIN-STATE";
-
-function pluginSection(content, selector) {
-  const escaped = JSON.stringify(selector).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return content.match(new RegExp(`\\[plugins\\.${escaped}\\][\\s\\S]*?(?=\\n\\[|$)`))?.[0] ?? "";
-}
-
-function repositorySelector(targetDir, config = "") {
-  const repository = inspectGeneratedRepositoryMarketplace(targetDir);
-  if (repository.status === "matched") return repository.selector;
-  return pluginSection(config, "agdf@agdf-repo") ? "agdf@agdf-repo" : "agdf@agdf";
-}
+import { planCodexRepositoryDisable, verifyCodexRepositoryDisabled, uninstallCommand as codexUninstallCommand } from "../host-adapters/codex/plugin.js";
+import { planClaudeGlobalUninstall, verifyClaudeGlobalUninstall } from "../host-adapters/claude/uninstall.js";
+import { revokeClaudeRuntimeRule } from "../runtime-check-consent/claude-settings.js";
+import { inspectPluginMcpDataRoot, retirePluginMcpDataRoot } from "../mcp-lifecycle/plugin-runtime.js";
+import { CODEX_DISPATCH_POLICY_KEY } from "../runtime-check-consent/codex-plugin-consent.js";
+import { defaultAgdfDataRoot } from "../installers/local-marketplace.js";
+import { uninstallCommand as copilotUninstallCommand } from "../host-adapters/copilot/plugin.js";
+import { atomicWrite } from "#agdf-core/control-state/run-state-writer.js";
+import { assertOwnedDirectory, assertUnchangedOwnedFile, directoryIdentity } from "./owned-mutation.js";
 
 export function planRepositoryDisable(targetDir, surface, { shared = false, exec = execFileSync } = {}) {
   if (surface === "copilot") {
@@ -42,137 +42,51 @@ export function planRepositoryDisable(targetDir, surface, { shared = false, exec
   if (surface !== "codex" || shared) {
     throw new Error(`Repository disable is not supported safely for ${surface}; no files were changed.`);
   }
-  const path = join(targetDir, ".codex", "config.toml");
-  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
-  const selector = repositorySelector(targetDir, existing);
-  const escaped = JSON.stringify(selector).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const sectionPattern = new RegExp(`\\[plugins\\.${escaped}\\][\\s\\S]*?(?=\\n\\[|$)`);
-  const currentSection = pluginSection(existing, selector);
-  const enabledMatches = [...currentSection.matchAll(/^enabled\s*=\s*(true|false)\s*$/gm)];
-  if (currentSection && enabledMatches.length !== 1) {
-    throw new Error(`Refusing to modify ambiguous AGDF plugin state in ${path}.`);
-  }
-  const section = currentSection
-    ? currentSection.replace(/^enabled\s*=\s*(true|false)\s*$/m, "enabled = false")
-    : `${CODEX_DISABLE_MARKER}\n[plugins.${JSON.stringify(selector)}]\nenabled = false`;
-  const content = currentSection
-    ? existing.replace(sectionPattern, section).replace(/\s*$/, "\n")
-    : `${existing.replace(/\s*$/, "")}${existing.trim() ? "\n\n" : ""}${section}\n`;
-  return Object.freeze({
-    operation: "disable",
-    surface,
-    scope: "repository",
-    mutations: Object.freeze([{ kind: "write", path, content, ownership: currentSection ? "exact_plugin_section" : "agdf_marker" }]),
-    retained: Object.freeze([join(targetDir, ".agdf", "control"), "global AGDF plugin availability"]),
-    expected: Object.freeze({ repository_status: "disabled" }),
-  });
+  return planCodexRepositoryDisable(targetDir);
 }
 
 export function verifyRepositoryDisabled(targetDir, surface = "codex", { shared = false } = {}) {
   if (surface === "copilot") return verifyCopilotRepositoryDisabled(targetDir, { shared });
   if (surface !== "codex") return { status: "failed", evidence: [`unsupported_surface:${surface}`] };
-  const path = join(targetDir, ".codex", "config.toml");
-  if (!existsSync(path)) return { status: "failed", evidence: [`missing:${path}`] };
-  const config = readFileSync(path, "utf8");
-  const selector = repositorySelector(targetDir, config);
-  const section = pluginSection(config, selector);
-  const matches = [...section.matchAll(/^enabled\s*=\s*(true|false)\s*$/gm)];
-  return matches.length === 1 && matches[0][1] === "false"
-    ? { status: "healthy", evidence: [`${path}:${selector}:enabled=false`] }
-    : { status: "failed", evidence: [`postcondition_failed:${path}:${selector}`] };
+  return verifyCodexRepositoryDisabled(targetDir);
 }
 
-export function verifyGlobalUninstall(plan, targetDir, { configDir, exec, inspect = inspectPluginSurface, evaluateOpenCode = evaluateOpenCodeStatus } = {}) {
+export function verifyGlobalUninstall(plan, _targetDir, {
+  configDir,
+  exec,
+  inspect = inspectPluginSurface,
+  evaluateOpenCodeGlobalStatus = inspectOpenCodeGlobalStatus,
+} = {}) {
   if (plan.surface === "opencode") {
-    const report = evaluateOpenCode(targetDir, configDir);
-    const remainingOwnedFiles = plan.mutations
-      .filter((mutation) => mutation.kind === "remove")
-      .map((mutation) => mutation.path)
-      .filter((path) => existsSync(path));
-    return report.status === "not_configured" && remainingOwnedFiles.length === 0
-      ? { status: "healthy", evidence: [report.global_config.path, "marker_owned_global_files_removed"] }
-      : { status: "failed", evidence: [report.global_config.path, ...remainingOwnedFiles.map((path) => `still_present:${path}`)] };
+    return verifyOpenCodeGlobalUninstall(plan, configDir, evaluateOpenCodeGlobalStatus);
   }
+  if (plan.surface === "claude") return verifyClaudeGlobalUninstall(plan, { ...(exec ? { exec } : {}), inspect });
   const report = inspect(plan.surface, exec);
   return report.status === "not_installed"
     ? { status: "healthy", evidence: report.evidence }
     : { status: "failed", evidence: [...report.evidence, `observed:${report.status}`] };
 }
 
-export function planGlobalUninstall(surface, { configDir } = {}) {
-  if (surface === "codex") {
-    return nativeUninstallPlan(surface, "codex", ["plugin", "remove", "agdf@agdf"]);
-  }
-  if (surface === "claude") {
-    return nativeUninstallPlan(surface, "claude", ["plugin", "uninstall", "agdf@agdf", "--scope", "user"]);
-  }
-  if (surface === "copilot") {
-    return nativeUninstallPlan(surface, "copilot", ["plugin", "uninstall", "agdf"]);
-  }
-  if (surface === "opencode") {
-    if (!configDir) throw new Error("OpenCode uninstall requires its explicit config directory.");
-    const configPath = join(configDir, "opencode.json");
-    if (!existsSync(configPath)) throw new Error(`OpenCode config not found: ${configPath}`);
-    let config;
-    try {
-      config = JSON.parse(readFileSync(configPath, "utf8"));
-    } catch {
-      throw new Error(`Refusing to modify unreadable OpenCode config: ${configPath}`);
-    }
-    if (config.plugin !== undefined && !Array.isArray(config.plugin)) {
-      throw new Error(`Refusing to modify OpenCode config with non-array plugin field: ${configPath}`);
-    }
-    const next = { ...config };
-    next.plugin = (config.plugin ?? []).filter((entry) => entry !== pluginDefinition.opencode.npmPackage);
-    if (Array.isArray(config.instructions)) next.instructions = config.instructions.filter((entry) => entry !== "AGDF.md");
-    const npm = openCodeNpmInvocation(["uninstall", "--silent", pluginDefinition.opencode.npmPackage]);
-    const mutations = [
-      { kind: "write", path: configPath, content: `${JSON.stringify(next, null, 2)}\n`, ownership: "exact_known_entries" },
-      { kind: "command", executable: npm.executable, args: npm.args, cwd: configDir },
-    ];
-    const retained = ["repository AGDF files", ".agdf/control"];
-    for (const candidate of openCodeOwnedGlobalFiles(configDir)) {
-      if (!existsSync(candidate.path)) continue;
-      const content = readFileSync(candidate.path, "utf8");
-      if (candidate.owned(content)) mutations.push({ kind: "remove", path: candidate.path, ownership: "agdf_marker" });
-      else retained.push(candidate.path);
-    }
-    return Object.freeze({
-      operation: "uninstall",
-      surface,
-      scope: "global",
-      mutations: Object.freeze(mutations),
-      retained: Object.freeze(retained),
-      expected: Object.freeze({ installation_status: "not_installed" }),
-    });
-  }
-  throw new Error(`Global uninstall is not supported for ${surface}.`);
-}
-
-function openCodeOwnedGlobalFiles(configDir) {
-  const firstLine = (marker) => (content) => content.split(/\r?\n/)[0] === marker;
-  const afterFrontmatter = (marker) => (content) => {
-    const lines = content.split(/\r?\n/);
-    const end = lines.findIndex((line, index) => index > 0 && line === "---");
-    return end >= 0 && lines[end + 1] === marker;
-  };
-  const files = [
-    { path: join(configDir, pluginDefinition.opencode.instructionsFileName), owned: firstLine("<!-- AGDF-GLOBAL-INSTRUCTIONS -->") },
-    { path: join(configDir, pluginDefinition.opencode.runtimeContractFileName), owned: firstLine("<!-- AGDF-GLOBAL-RUNTIME-CONTRACT -->") },
-    {
-      path: join(configDir, "agents", `${pluginDefinition.opencode.evaluatorAgentName}.md`),
-      owned: afterFrontmatter(`<!-- AGDF-GLOBAL-AGENT: ${pluginDefinition.opencode.evaluatorAgentName} -->`),
-    },
-  ];
-  for (const moduleName of ["gate-transition.md", "interaction.md", "modes.md", "quality.md", "context-graph.md", "control-scaffold.md", "closeout.md"]) {
-    files.push({ path: join(configDir, "contracts", moduleName), owned: firstLine("<!-- AGDF-GLOBAL-RUNTIME-CONTRACT -->") });
-  }
-  for (const skill of pluginDefinition.skillSet) {
-    const name = `${pluginDefinition.opencode.globalSkillPrefix}${skill.slug}`;
-    const marker = `<!-- AGDF-GLOBAL-SKILL: ${name} -->`;
-    files.push({ path: join(configDir, "skills", name, "SKILL.md"), owned: afterFrontmatter(marker) });
-  }
-  return files;
+export function planGlobalUninstall(surface, { configDir, ...claudeOptions } = {}) {
+  if (surface === "opencode") return planOpenCodeGlobalUninstall(configDir);
+  if (surface === "claude") return planClaudeGlobalUninstall(claudeOptions);
+  const command = surface === "codex" ? codexUninstallCommand()
+    : surface === "copilot" ? copilotUninstallCommand() : null;
+  if (!command) throw new Error(`Global uninstall is not supported for ${surface}.`);
+  const plan = nativeUninstallPlan(surface, command.executable, command.args);
+  if (surface !== "codex") return plan;
+  // The Codex plugin MCP runtime lives in the AGDF data root, which `codex plugin remove` never touches.
+  const runtimeRoot = join(defaultAgdfDataRoot({ env: claudeOptions.env ?? process.env }), "mcp", "codex-plugin");
+  const state = inspectPluginMcpDataRoot(runtimeRoot);
+  return Object.freeze({
+    ...plan,
+    mutations: Object.freeze([...plan.mutations, ...(state === "owned" ? [{ kind: "remove_tree", path: runtimeRoot, expectedIdentity: directoryIdentity(runtimeRoot) }]
+      : state === 'protected' ? [{ kind: 'retire_runtime', path: runtimeRoot, expectedIdentity: directoryIdentity(runtimeRoot) }] : []),
+      // The installer's tool approval lives in the Codex user config; it is revoked through Codex after removal.
+      { kind: "codex_tool_policy", key: CODEX_DISPATCH_POLICY_KEY }]),
+    retained: Object.freeze([...plan.retained, ...(state === "foreign" ? [`Codex plugin MCP runtime with unowned content: ${runtimeRoot}`]
+      : state === 'protected' ? [`Codex plugin MCP runtime retained for active, legacy or unconfirmed executable use: ${runtimeRoot}`] : [])]),
+  });
 }
 
 function nativeUninstallPlan(surface, executable, args) {
@@ -186,27 +100,54 @@ function nativeUninstallPlan(surface, executable, args) {
   });
 }
 
-export function applyLifecyclePlan(plan, { exec = execFileSync, applyCopilotSettings = applyCopilotRepositoryDisable } = {}) {
+export function applyLifecyclePlan(plan, { exec = execHostFileSync, applyCopilotSettings = applyCopilotRepositoryDisable } = {}) {
   const completed = [];
+  const retired = new Set();
+  const retained = () => plan.retained.filter(entry => ![...retired].some(path => entry.endsWith(': ' + path)));
   for (const mutation of plan.mutations) {
     try {
       if (mutation.kind === "write") {
+        assertUnchangedOwnedFile(mutation.path, mutation.expectedSnapshot);
         mkdirSync(dirname(mutation.path), { recursive: true });
-        writeFileSync(mutation.path, mutation.content, "utf8");
+        atomicWrite(mutation.path, mutation.content);
         completed.push({ kind: "write", path: mutation.path });
       } else if (mutation.kind === "copilot_settings") {
         const result = applyCopilotSettings(mutation.settings);
         completed.push({ kind: "copilot_settings", path: mutation.path, status: result.status });
       } else if (mutation.kind === "remove") {
+        assertUnchangedOwnedFile(mutation.path, mutation.expectedSnapshot);
         rmSync(mutation.path);
         completed.push({ kind: "remove", path: mutation.path });
+      } else if (mutation.kind === "remove_tree") {
+        const revalidate = () => assertOwnedDirectory(mutation.path, mutation.expectedIdentity, inspectPluginMcpDataRoot);
+        if (!retirePluginMcpDataRoot(mutation.path, revalidate)) throw Error('AGDF_MCP_RUNTIME_RETAINED');
+        completed.push({ kind: "remove_tree", path: mutation.path });
+      } else if (mutation.kind === 'retire_runtime') {
+        // Native removal can finish before its directly owned server has sent
+        // teardown acknowledgement. Observe the existing claim owner, never a
+        // PID or age heuristic. An unconfirmed/foreign runtime remains intact.
+        const deadline = performance.now() + 10_000;
+        let state = inspectPluginMcpDataRoot(mutation.path);
+        while (state === 'protected' && performance.now() < deadline) {
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+          state = inspectPluginMcpDataRoot(mutation.path);
+        }
+        if (state === 'owned') {
+          const revalidate = () => assertOwnedDirectory(mutation.path, mutation.expectedIdentity, inspectPluginMcpDataRoot);
+          if (retirePluginMcpDataRoot(mutation.path, revalidate)) {
+            completed.push({ kind: 'remove_tree', path: mutation.path }); retired.add(mutation.path);
+          }
+        } else if (state === 'absent') retired.add(mutation.path);
+      } else if (mutation.kind === "claude_permission_rules") {
+        for (const rule of mutation.rules) revokeClaudeRuntimeRule({ path: mutation.path, rule });
+        completed.push({ kind: "claude_permission_rules", path: mutation.path, rules: mutation.rules });
       } else if (mutation.kind === "command") {
         exec(mutation.executable, mutation.args, { cwd: mutation.cwd, stdio: "inherit" });
         completed.push({ kind: "command", executable: mutation.executable, args: mutation.args });
       }
     } catch (error) {
-      return { status: completed.length ? "partial" : "failed", completed, error, retained: [...plan.retained] };
+      return { status: completed.length ? "partial" : "failed", completed, error, retained: retained() };
     }
   }
-  return { status: "success", completed, error: null, retained: [...plan.retained] };
+  return { status: "success", completed, error: null, retained: retained() };
 }

package/lib/lifecycle/owned-mutation.js

@@ -0,0 +1,64 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+function conflict(path) {
+  const error = new Error(`AGDF_OWNERSHIP_CONFLICT: ${path}`);
+  error.code = "AGDF_OWNERSHIP_CONFLICT";
+  return error;
+}
+
+export function ownedFileSnapshot(path) {
+  // NTFS inode IDs can exceed Number precision; compare complete integer identities.
+  // A planned new file has no inode to check. Validate its nearest existing parent too, so a
+  // directory replaced by a symlink between plan and apply cannot redirect an atomic write.
+  let parentPath = dirname(path);
+  let parent;
+  for (;;) {
+    try {
+      parent = lstatSync(parentPath, { bigint: true });
+      if (parent.isSymbolicLink() || !parent.isDirectory()) throw conflict(path);
+      break;
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+      const next = dirname(parentPath);
+      if (next === parentPath) throw conflict(path);
+      parentPath = next;
+    }
+  }
+  let target;
+  try { target = lstatSync(path, { bigint: true }); }
+  catch (error) {
+    if (error?.code === "ENOENT") return {
+      parent: `${parent.dev}:${parent.ino}`, file: null, digest: null,
+    };
+    throw error;
+  }
+  if (target.isSymbolicLink() || !target.isFile()) throw conflict(path);
+  return { parent: `${parent.dev}:${parent.ino}`, file: `${target.dev}:${target.ino}`,
+    digest: createHash("sha256").update(readFileSync(path)).digest("hex") };
+}
+
+export function fileContentDigest(path) {
+  return ownedFileSnapshot(path).digest;
+}
+
+export function assertUnchangedOwnedFile(path, expectedSnapshot) {
+  const current = ownedFileSnapshot(path);
+  if (!expectedSnapshot || current.parent !== expectedSnapshot.parent
+      || current.file !== expectedSnapshot.file || current.digest !== expectedSnapshot.digest) throw conflict(path);
+}
+
+export function directoryIdentity(path) {
+  let type;
+  try { type = lstatSync(path, { bigint: true }); }
+  catch (error) { if (error?.code === "ENOENT") return null; throw error; }
+  if (type.isSymbolicLink() || !type.isDirectory()) throw conflict(path);
+  return `${type.dev}:${type.ino}`;
+}
+
+export function assertOwnedDirectory(path, expectedIdentity, inspect) {
+  if (!expectedIdentity || directoryIdentity(path) !== expectedIdentity || inspect(path) !== "owned") {
+    throw conflict(path);
+  }
+}

package/lib/lifecycle/presentation.js

@@ -7,12 +7,24 @@ const surfaceLabels = Object.freeze({
 });
 
 function titleFor(report) {
+  if (report.operation === "control_init") return report.result === "failed"
+    ? "AGDF control initialization failed"
+    : "AGDF control initialization complete";
+  if (report.operation === "repository_setup") return report.result === "success"
+    ? "AGDF repository setup complete"
+    : report.result === "partial" ? "AGDF repository setup partially completed"
+    : report.result === "preview" ? "AGDF repository setup preview"
+    : "AGDF repository setup failed";
+  if (report.operation === "disable") return report.result === "success"
+    ? "AGDF repository disable complete"
+    : report.result === "partial" ? "AGDF repository disable partially completed" : "AGDF repository disable failed";
+  if (report.operation === "uninstall") return report.result === "preview"
+    ? "AGDF uninstall preview"
+    : report.result === "success" ? "AGDF uninstall complete"
+    : report.result === "partial" ? "AGDF uninstall partially completed" : "AGDF uninstall failed";
   if (report.result === "failed") return "AGDF installation failed";
   if (report.result === "partial") return "AGDF installation partially completed";
-  if (report.result === "preview") return report.operation === "uninstall"
-    ? "AGDF uninstall preview"
-    : "AGDF installation cancelled";
-  if (report.operation === "repository_setup") return "AGDF repository setup complete";
+  if (report.result === "preview") return "AGDF installation cancelled";
   return "AGDF installation complete";
 }
 
@@ -26,6 +38,11 @@ export function lifecycleCardLines(report) {
   return [
     titleFor(report),
     `Surface: ${surfaceLabels[report.surface]}`,
+    `Operation: ${report.operation_status.operation_id}`,
+    `Operation outcome: ${report.operation_status.outcome}`,
+    `Target: ${report.operation_status.target ?? "global"}`,
+    `Planned effect: ${report.operation_status.planned_effect}`,
+    `Authorizes: ${report.operation_status.authorizes ? "yes" : "no"}`,
     `Version: ${version} (${versionStatus})`,
     `Installation scope: ${report.scope}`,
     `Installation: ${report.installation.status}`,
@@ -42,6 +59,7 @@ function friendlyRuntimeCheckState(report) {
   if (report.runtime_checks.requested === "cancelled") return "Cancelled";
   if (report.runtime_checks.effective === "enabled") return "On";
   if (report.runtime_checks.effective === "manual") return "Manual";
+  if (report.runtime_checks.verification === "hook_trusted_session_unverified") return "Hook trusted; fresh-session check pending";
   if (report.runtime_checks.effective === "decision_required") return `Waiting for ${surfaceLabels[report.surface]} permission`;
   if (report.runtime_checks.effective === "renewal_required") return "Needs your review";
   if (["degraded", "failed", "unavailable"].includes(report.runtime_checks.effective)) return "Not available; use manual checks";
@@ -60,13 +78,21 @@ function compactVersionLine(report) {
 export function compactLifecycleCardLines(report) {
   if (report.result === "preview") return [
     titleFor(report),
+    `Operation: ${report.operation_status.operation_id} (${report.operation_status.outcome}; ${report.operation_status.target ?? "global"})`,
     "No changes were made.",
     `Next: ${report.next_action.text}`,
   ];
+  if (report.operation === "control_init") return [
+    titleFor(report),
+    `Operation: ${report.operation_status.operation_id} (${report.operation_status.target})`,
+    `Control scaffold: ${report.operation_status?.outcome ?? "unknown"}`,
+    `Next: ${report.next_action.text}`,
+  ];
   return [
     report.result === "success"
       ? `AGDF ${report.operation === "update" ? "updated" : "installed"} for ${surfaceLabels[report.surface]}`
       : titleFor(report),
+    `Operation: ${report.operation_status.operation_id} (${report.operation_status.outcome}; ${report.operation_status.target ?? "global"})`,
     compactVersionLine(report),
     `Installation: ${report.installation.status === "healthy" ? "Ready" : report.installation.status}`,
     `Automatic checks: ${friendlyRuntimeCheckState(report)}`,
@@ -74,6 +100,15 @@ export function compactLifecycleCardLines(report) {
   ];
 }
 
+function describeChange(change) {
+  if (change.kind === "command") return [change.executable, ...(change.args ?? [])].join(" ");
+  if (change.kind === "claude_permission_rules") return `revoke ${change.rules.length} AGDF runtime-check permission rule(s) in ${change.path}`;
+  if (change.kind === "remove") return `remove ${change.path}`;
+  if (change.kind === "remove_tree") return `remove the owned AGDF plugin MCP runtime ${change.path}`;
+  if (change.kind === "codex_tool_policy") return `revoke the AGDF tool approval ${change.key} in the Codex user config`;
+  return typeof change === "string" ? change : JSON.stringify(change);
+}
+
 export function printLifecycleResult(report, { json = false, compact = false, io = console } = {}) {
   if (json) {
     io.log(JSON.stringify(report, null, 2));
@@ -81,6 +116,10 @@ export function printLifecycleResult(report, { json = false, compact = false, io
   }
   for (const line of compact ? compactLifecycleCardLines(report) : lifecycleCardLines(report)) io.log(line);
   if (report.failure) io.log(`Failure phase: ${report.failure.phase}: ${report.failure.message}`);
+  if (report.operation === "uninstall" && report.changes?.length) {
+    io.log(report.result === "preview" ? "Planned changes:" : "Changes:");
+    for (const change of report.changes) io.log(`- ${describeChange(change)}`);
+  }
   if (report.retained.length) {
     io.log("Retained:");
     for (const item of report.retained) io.log(`- ${typeof item === "string" ? item : JSON.stringify(item)}`);
@@ -93,9 +132,13 @@ export function printGeneralStatus(report, { json = false, io = console } = {})
     return;
   }
   io.log("AGDF status");
+  if (report.operation_status?.operation_id) io.log(`Operation: ${report.operation_status.operation_id}`);
   io.log(`Installation: ${report.installation.status}${report.installation.version ? ` (${report.installation.version})` : ""}`);
+  if (report.operation_status?.target) io.log(`Target: ${report.operation_status.target}`);
   io.log(`Repository: ${report.repository.status}`);
   io.log(`Delivery: ${report.delivery.status}${report.delivery.current_gate ? ` (${report.delivery.current_gate})` : ""}`);
   io.log(`Automatic runtime checks: requested=${report.runtime_checks.requested}; effective=${report.runtime_checks.effective}; reason=${report.runtime_checks.reason}`);
+  if (report.runtime_checks.verification) io.log(`Automatic-check verification: ${report.runtime_checks.verification}`);
+  io.log(`MCP: ${report.mcp?.result ?? report.mcp?.status ?? "not_checked"}`);
   io.log(`Next action: ${report.next_action.text}`);
 }