token-harness 0.1.15 → 0.1.17

package/token-harness.mjs

@@ -5051,7 +5051,7 @@ function updateState(row2) {
   }
 }
 function healthState(input) {
-  if (input.detection.state === "broken" || input.detection.versionVerdict === "unknown-newer" || input.verification === "degraded" || input.quality.state === "regressed" || input.conflicts.length > 0 || input.detection.warnings.some((warning2) => warning2.severity === "error")) {
+  if (input.detection.state === "broken" || input.verification === "degraded" || input.quality.state === "regressed" || input.conflicts.length > 0 || input.detection.warnings.some((warning2) => warning2.severity === "error")) {
     return "attention";
   }
   if (input.detection.state === "configured" && input.verification === "verified")
@@ -6535,12 +6535,33 @@ var init_install = __esm({
           version3 === null ? packageName : `${packageName}==${version3}`
         ],
         verified: true
+      },
+      uv: {
+        executable: "uv",
+        // Headroom uses uv's isolated tool installer. Token Harness invokes an existing uv only;
+        // it never bootstraps uv, Python, or administrator prerequisites.
+        args: (packageName, version3) => [
+          "tool",
+          "install",
+          "--force",
+          version3 === null ? packageName : `${packageName}==${version3}`
+        ],
+        verified: true
       }
     };
     UNINSTALL_COMMANDS = {
+      npm: {
+        executable: "npm",
+        args: (packageName) => ["uninstall", "--global", packageName]
+      },
       pipx: {
         executable: "pipx",
         args: (packageName) => ["uninstall", packageName]
+      },
+      uv: {
+        executable: "uv",
+        // Extras are install-time selectors; uv tool uninstall expects the distribution name.
+        args: (packageName) => ["tool", "uninstall", packageName.replace(/\[.*\]$/, "")]
       }
     };
     QUERY_COMMANDS = {
@@ -6633,17 +6654,35 @@ var init_install = __esm({
       },
       npm: {
         executable: "npm",
-        args: (packageName) => ["ls", "-g", packageName, "--depth=0"],
+        // Listing the global root as JSON proves both presence and absence without depending on
+        // localized human output or npm's exit behavior for a package-name filter.
+        args: () => ["ls", "--global", "--depth=0", "--json"],
         parse: (stdout, packageName) => {
-          const pattern = new RegExp(`(?:^|[^@\\w.-])${packageName}@(\\d[^\\s]*)`);
-          const match = pattern.exec(stdout);
-          const candidate = match?.[1] ?? null;
-          if (candidate === null || parseSemanticVersion(candidate) === null) {
+          let parsed;
+          try {
+            parsed = JSON.parse(stdout);
+          } catch {
+            return { status: "unknown", version: null };
+          }
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return { status: "unknown", version: null };
+          }
+          const dependencies = parsed["dependencies"];
+          if (dependencies === void 0)
+            return { status: "absent", version: null };
+          if (typeof dependencies !== "object" || dependencies === null || Array.isArray(dependencies)) {
+            return { status: "unknown", version: null };
+          }
+          const dependency = dependencies[packageName];
+          if (dependency === void 0)
+            return { status: "absent", version: null };
+          const candidate = typeof dependency === "string" ? dependency : typeof dependency === "object" && dependency !== null && !Array.isArray(dependency) ? dependency["version"] : null;
+          if (typeof candidate !== "string" || parseSemanticVersion(candidate) === null) {
             return { status: "unknown", version: null };
           }
           return { status: "captured", version: candidate };
         },
-        verified: false
+        verified: true
       },
       pnpm: {
         executable: "pnpm",
@@ -6698,16 +6737,20 @@ var init_install = __esm({
         executable: "uv",
         args: () => ["tool", "list"],
         parse: (stdout, packageName) => {
-          const pattern = new RegExp(`^${packageName}\\s+v?(\\S+)`, "m");
-          const match = pattern.exec(stdout);
-          if (match === null)
-            return { status: "absent", version: null };
-          const candidate = match[1] ?? "";
-          if (parseSemanticVersion(candidate) === null)
-            return { status: "unknown", version: null };
-          return { status: "captured", version: candidate };
+          const distribution = packageName.replace(/\[.*\]$/, "");
+          for (const line of stdout.split(/\r?\n/)) {
+            const fields = line.trim().split(/\s+/);
+            if (fields[0] !== distribution)
+              continue;
+            const candidate = (fields[1] ?? "").replace(/^v/i, "");
+            if (parseSemanticVersion(candidate) === null) {
+              return { status: "unknown", version: null };
+            }
+            return { status: "captured", version: candidate };
+          }
+          return { status: "absent", version: null };
         },
-        verified: false
+        verified: true
       },
       pipx: {
         executable: "pipx",
@@ -8892,7 +8935,7 @@ var init_snapshots = __esm({
        * calling a constructor directly.
        */
       static create(input) {
-        if (input.fs.isInside(input.backupRoot, input.projectRoot)) {
+        if (input.projectRoot !== null && input.fs.isInside(input.backupRoot, input.projectRoot)) {
           return {
             ok: false,
             diagnostics: [
@@ -9387,7 +9430,7 @@ var TOOL_VERSION;
 var init_version2 = __esm({
   "apps/cli/dist/src/version.js"() {
     "use strict";
-    TOOL_VERSION = "0.1.15";
+    TOOL_VERSION = "0.1.17";
   }
 });
 
@@ -11189,6 +11232,10 @@ var init_environment = __esm({
       "HOMEPATH",
       "LOCALAPPDATA",
       "NUMBER_OF_PROCESSORS",
+      // npm global installs must stay in the same prefix the parent process is using. This value is
+      // a filesystem location, not a credential; dropping it can update a different global npm tree
+      // while PATH continues to resolve the old executable.
+      "NPM_CONFIG_PREFIX",
       "PATH",
       "PATHEXT",
       "PROCESSOR_ARCHITECTURE",
@@ -11214,6 +11261,10 @@ var init_environment = __esm({
       "LC_ALL",
       "LC_CTYPE",
       "LOGNAME",
+      // npm documents config environment variables with the lowercase npm_config_ prefix on POSIX.
+      // Keep both common spellings because POSIX environment names are case-sensitive.
+      "NPM_CONFIG_PREFIX",
+      "npm_config_prefix",
       "PATH",
       "SHELL",
       "TMPDIR",
@@ -16088,6 +16139,25 @@ function parseHarnessCapabilities(value3) {
     narrowing: flags
   };
 }
+function parseCapabilityDigests(value3) {
+  if (value3 === void 0)
+    return {};
+  if (typeof value3 !== "object" || value3 === null || Array.isArray(value3))
+    return null;
+  const result6 = {};
+  for (const [harness, raw] of Object.entries(value3)) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+      return null;
+    const entries = {};
+    for (const [path, digest] of Object.entries(raw)) {
+      if (typeof digest !== "string" || !/^[a-f0-9]{64}$/i.test(digest))
+        return null;
+      entries[path.replaceAll("\\", "/")] = `sha256:${digest.toLowerCase()}`;
+    }
+    result6[harness] = entries;
+  }
+  return result6;
+}
 function parseCapabilities(stdout) {
   let parsed;
   try {
@@ -16100,7 +16170,8 @@ function parseCapabilities(stdout) {
   const record5 = parsed;
   const version3 = record5["version"];
   const harnesses = record5["harnesses"];
-  if (typeof version3 !== "string" || typeof harnesses !== "object" || harnesses === null) {
+  const digests = parseCapabilityDigests(record5["digests"]);
+  if (typeof version3 !== "string" || typeof harnesses !== "object" || harnesses === null || digests === null) {
     return null;
   }
   const entries = {};
@@ -16110,7 +16181,7 @@ function parseCapabilities(stdout) {
       return null;
     entries[harness] = entry;
   }
-  return { version: version3, harnesses: entries };
+  return { version: version3, harnesses: entries, digests };
 }
 async function probeCapabilities(context) {
   const outcome2 = await context.runner.run({
@@ -16185,13 +16256,27 @@ function driftWarning(message, remediation) {
 function formatSurface(surface) {
   return `${surface.toolFamily}/${surface.interceptionPoint}`;
 }
+function requiresRuntimeSkillDigests(capabilities) {
+  const observed = parseSemanticVersion(capabilities.version);
+  const minimum = parseSemanticVersion(RUNTIME_SKILL_DIGESTS_MINIMUM);
+  if (observed === null || minimum === null)
+    return true;
+  return compareVersions(observed, minimum) >= 0;
+}
+function publishedSkillArtifactDigests(capabilities, harness) {
+  const install = SKILLS_INSTALL[harness];
+  if (install === void 0)
+    return [];
+  const prefix = `${install.directory}/skills/`;
+  return Object.entries(capabilities.digests?.[harness] ?? {}).filter(([path]) => path.startsWith(prefix));
+}
 function assignableOn(capabilities) {
   if (capabilities === null)
     return [];
   const reviews = MANIFEST6.delegatedInstallReviews ?? {};
   return Object.keys(reviews).filter((harness) => {
     const observed = capabilities.harnesses[harness];
-    return observed !== void 0 && observed.narrowing.length > 0 && writeSetStillReviewed(capabilities, harnessId(harness));
+    return observed !== void 0 && observed.narrowing.length > 0 && writeSetStillReviewed(capabilities, harnessId(harness)) && (!requiresRuntimeSkillDigests(capabilities) || publishedSkillArtifactDigests(capabilities, harness).length > 0);
   }).map((harness) => harnessId(harness));
 }
 function writeSetStillReviewed(capabilities, harness) {
@@ -16239,6 +16324,15 @@ function compareCapabilities(manifest, capabilities) {
       warnings.push(driftWarning(`\`harnesstrim capabilities\` (${capabilities.version}) declares ${entry} for ${harness}, which sits outside the containment boundary recorded at ${review.upstreamVersion} (${boundary.join(", ")})`, "Re-review the write set: rollback restores the boundary, and a path it does not cover would survive a rollback"));
     }
   }
+  if (requiresRuntimeSkillDigests(capabilities)) {
+    for (const harness of Object.keys(manifest.delegatedInstallReviews ?? {})) {
+      if (capabilities.harnesses[harness] === void 0)
+        continue;
+      if (publishedSkillArtifactDigests(capabilities, harness).length > 0)
+        continue;
+      warnings.push(driftWarning(`HarnessTrim ${capabilities.version} does not publish the ${harness} skill artifact digests required by the managed install contract`, `Use a HarnessTrim build that publishes per-harness artifact digests, or update Token Harness if the upstream capability contract changed`));
+    }
+  }
   return warnings;
 }
 function harnessesWiredToHarnessTrim(configs) {
@@ -16332,7 +16426,7 @@ function metricsLocations(context) {
 async function detect6(context) {
   const probe = await probeExecutable(context);
   const observed = probe.installed ? await probeCapabilities(context) : null;
-  const configured = harnessesWiredToHarnessTrim(context.harnessConfigs);
+  const configured = await configuredHarnessesForHarnessTrim(context, observed?.capabilities ?? null);
   const warnings = [];
   const evidenceItems = [...probe.evidence, ...observed?.evidence ?? []];
   if (observed !== null && observed.capabilities !== null) {
@@ -16496,11 +16590,12 @@ async function verify6(context) {
     evidence: probe.evidence,
     remediation: probe.installed ? null : "Install HarnessTrim, or add it to PATH"
   });
-  const configured = harnessesWiredToHarnessTrim(context.harnessConfigs);
+  const currentCapabilities = probe.installed ? await probeCapabilities(context) : null;
+  const configured = await configuredHarnessesForHarnessTrim(context, currentCapabilities?.capabilities ?? null);
   checks.push({
-    id: "hook-registered",
+    id: "integration-configured",
     status: configured.length > 0 ? "pass" : "not-exercised",
-    summary: configured.length > 0 ? `wired to ${configured.join(", ")}` : "no harness configuration names harnesstrim",
+    summary: configured.length > 0 ? `configured for ${configured.join(", ")}` : "no HarnessTrim hook, plugin, or matching skills-only installation was found",
     achievedTier: configured.length > 0 ? "config-only" : null,
     evidence: [],
     remediation: null
@@ -16716,16 +16811,65 @@ async function collectMetrics(context, store) {
     diagnostics
   };
 }
-function skillArtifacts(context, harness) {
+function skillArtifacts(context, harness, capabilities = null) {
   const install = SKILLS_INSTALL[harness];
   if (install === void 0)
     return [];
+  const dynamic = capabilities === null ? [] : publishedSkillArtifactDigests(capabilities, harness).map(([path, digest]) => ({
+    path: context.fs.join(context.projectRoot, ...path.split("/")),
+    digest
+  }));
+  if (dynamic.length > 0)
+    return dynamic;
+  if (capabilities !== null && requiresRuntimeSkillDigests(capabilities))
+    return [];
   const skills = context.fs.join(context.projectRoot, install.directory, "skills");
   return Object.entries(SKILL_ARTIFACT_DIGESTS).map(([path, digest]) => ({
     path: context.fs.join(skills, ...path.split("/")),
     digest
   }));
 }
+function skillInstallContainmentBoundary(context, harness, capabilities, protectedPaths) {
+  const install = SKILLS_INSTALL[harness];
+  if (install === void 0)
+    return [...protectedPaths];
+  const prefix = `${install.directory}/skills/`;
+  const relativeArtifacts = capabilities === null ? [] : publishedSkillArtifactDigests(capabilities, harness).map(([path]) => path);
+  const fallbackArtifacts = Object.keys(SKILL_ARTIFACT_DIGESTS).map((path) => `${install.directory}/skills/${path}`);
+  const contract = relativeArtifacts.length > 0 ? relativeArtifacts : capabilities !== null && requiresRuntimeSkillDigests(capabilities) ? [] : fallbackArtifacts;
+  const skillRoots = /* @__PURE__ */ new Set();
+  for (const relative of contract) {
+    if (!relative.startsWith(prefix))
+      continue;
+    const first = relative.slice(prefix.length).split("/")[0];
+    if (first) {
+      skillRoots.add(context.fs.join(context.projectRoot, install.directory, "skills", first));
+    }
+  }
+  return [...skillRoots, ...protectedPaths];
+}
+async function harnessTrimSkillsConfigured(context, harness, capabilities) {
+  const artifacts = skillArtifacts(context, harness, capabilities);
+  if (artifacts.length === 0)
+    return false;
+  for (const artifact of artifacts) {
+    const stat3 = await context.fs.stat(artifact.path);
+    if (stat3 === null || stat3.kind !== "file")
+      return false;
+    const actual = digestText(new TextDecoder().decode(await context.fs.readFile(artifact.path)));
+    if (actual !== artifact.digest)
+      return false;
+  }
+  return true;
+}
+async function configuredHarnessesForHarnessTrim(context, capabilities) {
+  const configured = new Set(harnessesWiredToHarnessTrim(context.harnessConfigs));
+  for (const harness of [CLAUDE2, CODEX2]) {
+    if (await harnessTrimSkillsConfigured(context, harness, capabilities))
+      configured.add(harness);
+  }
+  return [...configured];
+}
 async function plan(context, request) {
   const reviews = MANIFEST6.delegatedInstallReviews ?? {};
   const targets = request.harnesses.map((harness) => harness.id).filter((harness) => reviews[harness] !== void 0 && SKILLS_INSTALL[harness] !== void 0);
@@ -16737,8 +16881,11 @@ async function plan(context, request) {
       targetHarnesses: []
     };
   }
+  const installed2 = await probeExecutable(context);
+  const observed = installed2.installed ? await probeCapabilities(context) : null;
+  const currentCapabilities = observed?.capabilities ?? null;
   if (request.desiredState === "absent") {
-    const actions2 = targets.flatMap((harness) => skillArtifacts(context, harness).map((artifact) => ({
+    const actions2 = targets.flatMap((harness) => skillArtifacts(context, harness, currentCapabilities).map((artifact) => ({
       kind: "remove-owned-change",
       id: `harnesstrim-${harness}-skill-remove-${digestText(artifact.path).slice(7, 15)}`,
       riskClass: "reversible",
@@ -16747,7 +16894,7 @@ async function plan(context, request) {
       affectedPaths: [artifact.path],
       affectedProcesses: [],
       preconditions: [
-        `the HarnessTrim skill still matches the reviewed ${SKILLS_UPSTREAM} artifact`
+        `the HarnessTrim skill still matches the installed HarnessTrim artifact contract`
       ],
       postconditions: ["the owned HarnessTrim skill is absent"],
       rollbackData: "file-snapshot",
@@ -16768,7 +16915,6 @@ async function plan(context, request) {
       targetHarnesses: actions2.length === 0 ? [] : targets.map((harness) => harnessId(harness))
     };
   }
-  const installed2 = await probeExecutable(context);
   if (!installed2.installed) {
     return {
       providerId: HARNESSTRIM2,
@@ -16777,7 +16923,6 @@ async function plan(context, request) {
       targetHarnesses: []
     };
   }
-  const observed = await probeCapabilities(context);
   const actions = [];
   const plannedHarnesses = [];
   for (const harness of targets) {
@@ -16785,10 +16930,17 @@ async function plan(context, request) {
     const install = SKILLS_INSTALL[harness];
     if (review === void 0 || install === void 0)
       continue;
-    const reviewed = observed.capabilities === null ? installed2.version === review.upstreamVersion : writeSetStillReviewed(observed.capabilities, harnessId(harness));
+    const reviewed = currentCapabilities === null ? installed2.version === review.upstreamVersion : writeSetStillReviewed(currentCapabilities, harnessId(harness));
     if (!reviewed)
       continue;
-    const expectedArtifacts = skillArtifacts(context, harness);
+    const expectedArtifacts = skillArtifacts(context, harness, currentCapabilities);
+    if (expectedArtifacts.length === 0)
+      continue;
+    const protectedPaths = [
+      context.fs.join(context.projectRoot, install.directory, install.hook),
+      context.fs.join(context.projectRoot, install.instructions)
+    ];
+    const containmentBoundary = skillInstallContainmentBoundary(context, harness, currentCapabilities, protectedPaths);
     actions.push({
       kind: "delegated-provider-install",
       id: `harnesstrim-${harness}-skills-${digestText(context.projectRoot).slice(7, 15)}`,
@@ -16798,24 +16950,21 @@ async function plan(context, request) {
       affectedPaths: expectedArtifacts.map((artifact) => artifact.path),
       affectedProcesses: ["harnesstrim"],
       preconditions: [
-        "harnesstrim is installed, on PATH, and declares the reviewed write set",
-        `the reviewed installer writes only the declared ${harness} skill artifacts`
+        "harnesstrim is installed, on PATH, and declares a compatible write set",
+        `the installed HarnessTrim build publishes the exact ${harness} skill artifact contract`
       ],
       postconditions: [
-        `HarnessTrim ${harness} skills match the reviewed ${review.upstreamVersion} artifacts`,
+        `HarnessTrim ${harness} skills match the installed ${installed2.version ?? review.upstreamVersion} artifact contract`,
         "no HarnessTrim hook or reduce-pipe instruction was added"
       ],
       rollbackData: "directory-snapshot",
       explanation: `Install HarnessTrim ${harness} skills without a hook or reduce-pipe instruction`,
       executable: "harnesstrim",
       args: ["install", harness, context.projectRoot, "--apply", ...install.args],
-      containmentBoundary: review.containmentBoundary.map((path) => context.fs.join(context.projectRoot, path)),
+      containmentBoundary,
       expectedArtifacts,
       // The two files each installer reports skipping. Named here because they must not appear.
-      protectedPaths: [
-        context.fs.join(context.projectRoot, install.directory, install.hook),
-        context.fs.join(context.projectRoot, install.instructions)
-      ],
+      protectedPaths,
       rollbackStrategy: "restore-snapshot",
       snapshotSizeCapBytes: 1048576,
       upstreamUninstallAvailable: review.upstreamUninstallAvailable
@@ -16829,7 +16978,7 @@ async function plan(context, request) {
     targetHarnesses: plannedHarnesses
   };
 }
-var HARNESSTRIM2, CLAUDE2, HERMES2, CODEX2, PI2, SKILLS_UPSTREAM, SKILL_ARTIFACT_DIGESTS, SKILL_ARTIFACTS, OPENCODE2, MODE_CARRYING_HARNESSES, HOOK_COMMAND_PATTERN, PLUGIN_MODULE_PATTERN2, PI_EXTENSION_PATTERN, MANIFEST6, SKILLS_INSTALL, TESTED_UPSTREAM, TESTED_VERSIONS, SURFACE_ANCHORS, VERSION_PATTERN6, harnesstrimAdapter;
+var HARNESSTRIM2, CLAUDE2, HERMES2, CODEX2, PI2, SKILLS_UPSTREAM, RUNTIME_SKILL_DIGESTS_MINIMUM, SKILL_ARTIFACT_DIGESTS, SKILL_ARTIFACTS, OPENCODE2, MODE_CARRYING_HARNESSES, HOOK_COMMAND_PATTERN, PLUGIN_MODULE_PATTERN2, PI_EXTENSION_PATTERN, MANIFEST6, SKILLS_INSTALL, TESTED_UPSTREAM, TESTED_VERSIONS, SURFACE_ANCHORS, VERSION_PATTERN6, harnesstrimAdapter;
 var init_harnesstrim = __esm({
   "packages/adapters/dist/src/providers/harnesstrim.js"() {
     "use strict";
@@ -16840,6 +16989,7 @@ var init_harnesstrim = __esm({
     CODEX2 = harnessId("codex");
     PI2 = harnessId("pi");
     SKILLS_UPSTREAM = "0.0.7";
+    RUNTIME_SKILL_DIGESTS_MINIMUM = "0.2.0";
     SKILL_ARTIFACT_DIGESTS = {
       "compact-handoff/SKILL.md": "sha256:0efbf35581c559359e755b204778b64a289dab4d20dadc1cba3d5b5c995b5f01",
       "debug-log-slim/SKILL.md": "sha256:17f5ccc34d29d7aba083444e0e4d87fd3d49916ebcb4e6544caf8c89f13f0045",
@@ -18088,15 +18238,87 @@ var init_gitnexus_candidate = __esm({
 function claudeTarget(context) {
   return context.fs.join(context.paths.home, ".claude.json");
 }
-function prerequisiteDiagnostic(harness, version3, supportsMcp) {
+async function observeGitNexusManagedRuntime(context) {
+  const versionOutcome = await context.runner.run({
+    executable: "gitnexus",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (versionOutcome.failure !== null) {
+    return {
+      ready: false,
+      absent: versionOutcome.failure.reason === "executable-not-found",
+      version: null,
+      executable: versionOutcome.executablePath,
+      supportsMcp: false,
+      detail: `gitnexus --version failed: ${versionOutcome.failure.reason}`
+    };
+  }
+  const version3 = parseGitNexusVersion(`${versionOutcome.stdout}
+${versionOutcome.stderr}`);
+  const actual = version3 === null ? null : parseSemanticVersion(version3);
+  const floor = parseSemanticVersion(GITNEXUS_REVIEWED_MCP_VERSION);
+  const newEnough = actual !== null && floor !== null && compareVersions(actual, floor) >= 0;
+  if (versionOutcome.exitCode !== 0 || !newEnough) {
+    return {
+      ready: false,
+      absent: false,
+      version: version3,
+      executable: versionOutcome.executablePath,
+      supportsMcp: false,
+      detail: version3 === null ? "GitNexus did not report a semantic version" : `GitNexus ${version3} predates the managed MCP floor ${GITNEXUS_REVIEWED_MCP_VERSION}`
+    };
+  }
+  const help = await context.runner.run({
+    executable: "gitnexus",
+    args: ["--help"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  const capabilities = help.failure === null && help.exitCode === 0 ? parseGitNexusCliCapabilities(`${help.stdout}
+${help.stderr}`, "") : { query: false, context: false, statusJson: false, mcp: false };
+  return {
+    ready: capabilities.mcp,
+    absent: false,
+    version: version3,
+    executable: versionOutcome.executablePath,
+    supportsMcp: capabilities.mcp,
+    detail: capabilities.mcp ? `GitNexus ${version3} exposes the MCP command required by the managed Claude integration` : `GitNexus ${version3} does not advertise the MCP command required by the managed Claude integration`
+  };
+}
+function prerequisiteDiagnostic(harness, detail2) {
   return diagnostic({
     severity: "warning",
     code: "gitnexus-managed-mcp-prerequisite",
     subject: harness,
-    message: version3 === null ? "GitNexus is not available on the reviewed managed MCP surface" : supportsMcp ? `GitNexus ${version3} is not the reviewed managed MCP version ${GITNEXUS_REVIEWED_MCP_VERSION}` : `GitNexus ${version3} does not advertise the reviewed MCP command`,
-    remediation: `Keep the current installation user-owned; this build manages MCP registration only for GitNexus ${GITNEXUS_REVIEWED_MCP_VERSION}`
+    message: detail2,
+    remediation: `Install or update GitNexus to ${GITNEXUS_REVIEWED_MCP_VERSION} or newer with the MCP command, then refresh Token Harness`
   });
 }
+function gitnexusInstallAction() {
+  return {
+    kind: "package-manager-install",
+    id: `gitnexus:install:${GITNEXUS_REVIEWED_MCP_VERSION}`,
+    riskClass: "delegated",
+    requiresNetwork: true,
+    requiresElevation: false,
+    affectedPaths: [],
+    affectedProcesses: ["npm"],
+    preconditions: [
+      "npm remains runnable",
+      `the reviewed GitNexus ${GITNEXUS_REVIEWED_MCP_VERSION} package remains installable`
+    ],
+    postconditions: [
+      `GitNexus ${GITNEXUS_REVIEWED_MCP_VERSION} is installed and exposes the mcp command`
+    ],
+    rollbackData: "package-inventory",
+    explanation: `Install the reviewed GitNexus ${GITNEXUS_REVIEWED_MCP_VERSION} CLI through npm`,
+    packageManager: "npm",
+    packageName: "gitnexus",
+    version: GITNEXUS_REVIEWED_MCP_VERSION
+  };
+}
 async function planGitNexusManagedMcpActivation(context, harness) {
   if (harness !== "claude") {
     return {
@@ -18114,14 +18336,40 @@ async function planGitNexusManagedMcpActivation(context, harness) {
       ]
     };
   }
-  const observation = await observeGitNexusCandidate(context);
-  if (observation.state !== "benchmark-ready" || observation.version !== GITNEXUS_REVIEWED_MCP_VERSION || !observation.supportsMcp) {
-    return {
-      harness,
-      target: null,
-      actions: [],
-      diagnostics: [prerequisiteDiagnostic(harness, observation.version, observation.supportsMcp)]
-    };
+  const observation = await observeGitNexusManagedRuntime(context);
+  const installActions = [];
+  if (!observation.ready) {
+    if (!observation.absent) {
+      return {
+        harness,
+        target: null,
+        actions: [],
+        diagnostics: [prerequisiteDiagnostic(harness, observation.detail)]
+      };
+    }
+    const npm = await context.runner.run({
+      executable: "npm",
+      args: ["--version"],
+      cwd: context.projectRoot,
+      timeoutMs: 2e4
+    });
+    if (npm.failure !== null || npm.exitCode !== 0) {
+      return {
+        harness,
+        target: null,
+        actions: [],
+        diagnostics: [
+          diagnostic({
+            severity: "warning",
+            code: "gitnexus-npm-unavailable",
+            subject: harness,
+            message: "GitNexus is absent and npm is not available in this terminal",
+            remediation: "Make npm available on PATH, then refresh Token Harness. Token Harness will not bootstrap Node.js or administrator prerequisites."
+          })
+        ]
+      };
+    }
+    installActions.push(gitnexusInstallAction());
   }
   const target = claudeTarget(context);
   if (!context.fs.isInside(target, context.paths.home)) {
@@ -18239,7 +18487,7 @@ async function planGitNexusManagedMcpActivation(context, harness) {
     ],
     createIfMissing: true
   };
-  return { harness, target, actions: [action], diagnostics: [] };
+  return { harness, target, actions: [...installActions, action], diagnostics: [] };
 }
 function planGitNexusManagedMcpRemoval(context, ownership) {
   const harness = "claude";
@@ -18287,12 +18535,12 @@ async function verifyGitNexusManagedMcpActivation(context, harness) {
       detail: "Managed GitNexus MCP verification is currently reviewed only for Claude Code"
     };
   }
-  const observation = await observeGitNexusCandidate(context);
-  if (observation.state !== "benchmark-ready" || observation.version !== GITNEXUS_REVIEWED_MCP_VERSION || !observation.supportsMcp) {
+  const observation = await observeGitNexusManagedRuntime(context);
+  if (!observation.ready) {
     return {
       state: "candidate-unavailable",
       target: null,
-      detail: observation.reasons.join("; ")
+      detail: observation.detail
     };
   }
   const target = claudeTarget(context);
@@ -18327,7 +18575,7 @@ async function verifyGitNexusManagedMcpActivation(context, harness) {
   return {
     state: "verified",
     target,
-    detail: `GitNexus ${GITNEXUS_REVIEWED_MCP_VERSION} is registered through the reviewed Claude MCP entry; verification did not start the MCP server`
+    detail: `GitNexus ${observation.version ?? ""} is registered through the Token Harness-owned Claude MCP entry; verification did not start the MCP server`
   };
 }
 var GITNEXUS_REVIEWED_MCP_VERSION, GITNEXUS_CLAUDE_MCP_POINTER, GITNEXUS_MCP_SERVER, DECODER;
@@ -18479,6 +18727,28 @@ var init_headroom_candidate = __esm({
 function parseMcptoonVersion(text3) {
   return VERSION_PATTERN10.exec(text3)?.[1] ?? null;
 }
+function numericCore2(version3) {
+  const core = version3.split(/[-+]/, 1)[0];
+  if (core === void 0)
+    return null;
+  const parts = core.split(".").map((part) => Number.parseInt(part, 10));
+  if (parts.length !== 3 || parts.some((part) => !Number.isInteger(part) || part < 0))
+    return null;
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function mcptoonVersionAtLeast(version3, minimum) {
+  const actual = numericCore2(version3);
+  const floor = numericCore2(minimum);
+  if (actual === null || floor === null)
+    return false;
+  for (let index = 0; index < 3; index += 1) {
+    const left = actual[index] ?? 0;
+    const right = floor[index] ?? 0;
+    if (left !== right)
+      return left > right;
+  }
+  return !(version3.includes("-") && !minimum.includes("-"));
+}
 function parseMcptoonManifestCapabilities(text3) {
   const lower = text3.toLowerCase();
   return {
@@ -18586,6 +18856,50 @@ var init_mcptoon_candidate = __esm({
 });
 
 // packages/adapters/dist/src/providers/mcptoon-managed.js
+async function observeMcptoonManagedRuntime(context) {
+  const versionOutcome = await context.runner.run({
+    executable: "mcptoon",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (versionOutcome.failure !== null) {
+    return {
+      ready: false,
+      absent: versionOutcome.failure.reason === "executable-not-found",
+      version: null,
+      executable: versionOutcome.executablePath,
+      detail: `mcptoon --version failed: ${versionOutcome.failure.reason}`
+    };
+  }
+  const version3 = parseMcptoonVersion(`${versionOutcome.stdout}
+${versionOutcome.stderr}`);
+  if (versionOutcome.exitCode !== 0 || version3 === null || !mcptoonVersionAtLeast(version3, MCPTOON_MANAGED_MINIMUM_VERSION)) {
+    return {
+      ready: false,
+      absent: false,
+      version: version3,
+      executable: versionOutcome.executablePath,
+      detail: version3 === null ? "mcptoon did not report a semantic version" : `mcptoon ${version3} predates the managed runtime floor ${MCPTOON_MANAGED_MINIMUM_VERSION}`
+    };
+  }
+  const help = await context.runner.run({
+    executable: "mcptoon",
+    args: ["--help"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  const capabilities = help.failure === null && help.exitCode === 0 ? parseMcptoonManifestCapabilities(`${help.stdout}
+${help.stderr}`) : { compact: false, json: false };
+  const ready = capabilities.compact && capabilities.json;
+  return {
+    ready,
+    absent: false,
+    version: version3,
+    executable: versionOutcome.executablePath,
+    detail: ready ? `mcptoon ${version3} exposes the compact/JSON CLI surfaces used by the managed integration` : `mcptoon ${version3} no longer advertises the compact/JSON CLI surfaces required by the managed integration`
+  };
+}
 function mcptoonInstallAction() {
   return {
     kind: "package-manager-install",
@@ -18811,11 +19125,11 @@ async function planMcptoonManagedActivation(context, harness) {
       ]
     };
   }
-  const observation = await observeMcptoonCandidate(context);
+  const observation = await observeMcptoonManagedRuntime(context);
   const activation = harness === "claude" ? await planClaudeActivation(context, harness) : await planCodexActivation(context, harness);
-  if (observation.state === "benchmark-ready")
+  if (observation.ready)
     return activation;
-  if (observation.state === "absent") {
+  if (observation.absent) {
     const activationSatisfied = activation.diagnostics.some((entry) => entry.code === "mcptoon-guidance-already-present");
     if (activation.actions.length === 0 && !activationSatisfied) {
       return activation;
@@ -18867,19 +19181,19 @@ async function planMcptoonManagedActivation(context, harness) {
         severity: "warning",
         code: "mcptoon-managed-prerequisite",
         subject: harness,
-        message: `mcptoon ${observation.version ?? ""} is runnable but not on the reviewed managed-activation surface`.trim(),
-        remediation: `Keep the existing installation user-owned, or move to the exact reviewed mcptoon ${MCPTOON_REVIEWED_INSTALL_VERSION} build`
+        message: observation.detail,
+        remediation: `Update mcptoon to ${MCPTOON_MANAGED_MINIMUM_VERSION} or newer with the required compact/JSON CLI surfaces, then refresh Token Harness`
       })
     ]
   };
 }
 async function verifyMcptoonManagedActivation(context, harness) {
-  const observation = await observeMcptoonCandidate(context);
-  if (observation.state !== "benchmark-ready") {
+  const observation = await observeMcptoonManagedRuntime(context);
+  if (!observation.ready) {
     return {
       state: "candidate-unavailable",
       target: null,
-      detail: observation.reasons.join("; ")
+      detail: observation.detail
     };
   }
   let target;
@@ -18906,22 +19220,23 @@ async function verifyMcptoonManagedActivation(context, harness) {
     return {
       state: "not-configured",
       target,
-      detail: "The reviewed mcptoon agent instructions are not present"
+      detail: "The Token Harness mcptoon agent instructions are not present"
     };
   }
   return {
     state: "verified",
     target,
-    detail: "Reviewed agent instructions are present and mcptoon exposes the reviewed passive CLI capabilities"
+    detail: `Agent instructions are present and mcptoon ${observation.version ?? ""} exposes the required passive CLI capabilities`
   };
 }
-var MCPTOON_REVIEWED_INSTALL_VERSION, MCPTOON_MARKER_BEGIN, MCPTOON_MARKER_END, MCPTOON_AGENT_INSTRUCTIONS, MCPTOON_CLAUDE_SKILL, DECODER2;
+var MCPTOON_REVIEWED_INSTALL_VERSION, MCPTOON_MANAGED_MINIMUM_VERSION, MCPTOON_MARKER_BEGIN, MCPTOON_MARKER_END, MCPTOON_AGENT_INSTRUCTIONS, MCPTOON_CLAUDE_SKILL, DECODER2;
 var init_mcptoon_managed = __esm({
   "packages/adapters/dist/src/providers/mcptoon-managed.js"() {
     "use strict";
     init_src();
     init_mcptoon_candidate();
     MCPTOON_REVIEWED_INSTALL_VERSION = "0.7.10";
+    MCPTOON_MANAGED_MINIMUM_VERSION = MCPTOON_REVIEWED_INSTALL_VERSION;
     MCPTOON_MARKER_BEGIN = "TOKEN-HARNESS:MCPTOON:BEGIN";
     MCPTOON_MARKER_END = "TOKEN-HARNESS:MCPTOON:END";
     MCPTOON_AGENT_INSTRUCTIONS = `Use mcptoon as the CLI gateway for MCP tools when a task needs one.
@@ -18961,7 +19276,7 @@ function warning(code, subject, message) {
     code,
     subject,
     message,
-    remediation: "Use the exact reviewed version before asking Token Harness to change this tool."
+    remediation: "Update the provider or restore the CLI capability this managed integration requires, then refresh Token Harness."
   });
 }
 function unavailableMetrics(provider) {
@@ -18976,53 +19291,79 @@ function unavailableMetrics(provider) {
   };
 }
 async function mcptoonDetection(context) {
-  const observation = await observeMcptoonCandidate(context);
+  const observation = await observeMcptoonManagedRuntime(context);
   const configuredHarnesses = [];
-  if (observation.version === MCPTOON_REVIEWED_BENCHMARK_VERSION) {
+  if (observation.ready) {
     for (const harness of [CLAUDE5, CODEX3]) {
       const verification = await verifyMcptoonManagedActivation(context, harness);
       if (verification.state === "verified")
         configuredHarnesses.push(harness);
     }
   }
-  const warnings = observation.state === "unsupported-version" ? [
-    warning("mcptoon-provider-version-unreviewed", "mcptoon", observation.reasons[0] ?? "The installed mcptoon version is outside the reviewed row.")
-  ] : [];
+  const pipx = observation.absent ? await context.runner.run({
+    executable: "pipx",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  }) : null;
+  const canInstall = observation.absent && pipx !== null && pipx.failure === null && pipx.exitCode === 0;
+  const warnings = observation.absent && !canInstall ? [
+    diagnostic({
+      severity: "warning",
+      code: "mcptoon-pipx-unavailable",
+      subject: "mcptoon",
+      message: "mcptoon is not installed and pipx is not available in this terminal",
+      remediation: "Install pipx or make it available on PATH, then refresh. Token Harness will use it to install the reviewed mcptoon build."
+    })
+  ] : !observation.absent && !observation.ready ? [warning("mcptoon-provider-capability-unavailable", "mcptoon", observation.detail)] : [];
   return {
     providerId: MCPTOON,
-    state: observation.state === "absent" ? "absent" : configuredHarnesses.length > 0 ? "configured" : "installed",
+    state: observation.absent ? "absent" : configuredHarnesses.length > 0 ? "configured" : "installed",
     version: observation.version,
     executable: observation.executable,
-    installationChannel: observation.state === "absent" ? "pipx" : null,
+    installationChannel: observation.absent ? "pipx" : null,
     versionVerdict: versionVerdict(observation.version, MCPTOON_REVIEWED_BENCHMARK_VERSION),
     configuredHarnesses,
     unmanagedHarnessesConfigured: [],
     supportsUnmanagedHarnesses: false,
     managedByTokenHarness: false,
-    assignableHarnesses: observation.version === MCPTOON_REVIEWED_BENCHMARK_VERSION ? [CLAUDE5, CODEX3] : [],
+    assignableHarnesses: observation.ready || canInstall ? [CLAUDE5, CODEX3] : [],
     evidence: [],
     warnings
   };
 }
 async function gitnexusDetection(context) {
-  const observation = await observeGitNexusCandidate(context);
-  const verification = observation.version === GITNEXUS_REVIEWED_BENCHMARK_VERSION ? await verifyGitNexusManagedMcpActivation(context, CLAUDE5) : null;
+  const observation = await observeGitNexusManagedRuntime(context);
+  const verification = observation.ready ? await verifyGitNexusManagedMcpActivation(context, CLAUDE5) : null;
   const configuredHarnesses = verification?.state === "verified" ? [CLAUDE5] : [];
-  const warnings = observation.state === "unsupported-version" ? [
-    warning("gitnexus-provider-version-unreviewed", "gitnexus", observation.reasons[0] ?? "The installed GitNexus version is outside the reviewed row.")
-  ] : [];
+  const npm = observation.absent ? await context.runner.run({
+    executable: "npm",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  }) : null;
+  const canInstall = observation.absent && npm !== null && npm.failure === null && npm.exitCode === 0;
+  const warnings = observation.absent && !canInstall ? [
+    diagnostic({
+      severity: "warning",
+      code: "gitnexus-npm-unavailable",
+      subject: "gitnexus",
+      message: "GitNexus is not installed and npm is not available in this terminal",
+      remediation: "Make npm available on PATH, then refresh. Token Harness can install the reviewed GitNexus build after explicit approval."
+    })
+  ] : !observation.absent && !observation.ready ? [warning("gitnexus-provider-capability-unavailable", "gitnexus", observation.detail)] : [];
   return {
     providerId: GITNEXUS,
-    state: observation.state === "absent" ? "absent" : configuredHarnesses.length > 0 ? "configured" : "installed",
+    state: observation.absent ? "absent" : configuredHarnesses.length > 0 ? "configured" : "installed",
     version: observation.version,
     executable: observation.executable,
-    installationChannel: observation.state === "absent" ? "npm" : null,
+    installationChannel: observation.absent ? "npm" : null,
     versionVerdict: versionVerdict(observation.version, GITNEXUS_REVIEWED_BENCHMARK_VERSION),
     configuredHarnesses,
     unmanagedHarnessesConfigured: [],
     supportsUnmanagedHarnesses: false,
     managedByTokenHarness: false,
-    assignableHarnesses: observation.version === GITNEXUS_REVIEWED_BENCHMARK_VERSION && observation.supportsMcp ? [CLAUDE5] : [],
+    assignableHarnesses: observation.ready || canInstall ? [CLAUDE5] : [],
     evidence: [],
     warnings
   };
@@ -19322,12 +19663,15 @@ function directoryAction2(harness, path) {
     path
   };
 }
-async function reviewedMcpCliAvailable(context) {
+async function headroomManagedMcpRuntime(context) {
   const observation = await observeHeadroomCandidate(context);
-  if (observation.version !== HEADROOM_REVIEWED_MCP_VERSION) {
+  const compatible = observation.version !== null && headroomVersionAtLeast(observation.version, HEADROOM_REVIEWED_MCP_VERSION);
+  if (!compatible) {
     return {
       ok: false,
-      detail: observation.version === null ? `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} is not installed` : `Headroom ${observation.version} is installed; managed MCP activation is reviewed only for ${HEADROOM_REVIEWED_MCP_VERSION}`
+      version: observation.version,
+      executable: observation.executable,
+      detail: observation.version === null ? `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} or newer is not installed` : `Headroom ${observation.version} predates the managed MCP floor ${HEADROOM_REVIEWED_MCP_VERSION}`
     };
   }
   const help = await context.runner.run({
@@ -19339,12 +19683,40 @@ async function reviewedMcpCliAvailable(context) {
   if (help.failure !== null || help.exitCode !== 0) {
     return {
       ok: false,
-      detail: `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} is installed but its reviewed MCP server command is unavailable`
+      version: observation.version,
+      executable: observation.executable,
+      detail: `Headroom ${observation.version} is installed but its MCP server command is unavailable`
     };
   }
   return {
     ok: true,
-    detail: `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} exposes the reviewed local MCP server`
+    version: observation.version,
+    executable: observation.executable,
+    detail: `Headroom ${observation.version} exposes the local MCP server required by the managed integration`
+  };
+}
+function headroomInstallAction() {
+  return {
+    kind: "package-manager-install",
+    id: `headroom:install:${HEADROOM_REVIEWED_MCP_VERSION}`,
+    riskClass: "delegated",
+    requiresNetwork: true,
+    requiresElevation: false,
+    affectedPaths: [],
+    affectedProcesses: ["uv"],
+    preconditions: [
+      "uv remains runnable",
+      `the reviewed Headroom ${HEADROOM_REVIEWED_MCP_VERSION} MCP package remains installable`
+    ],
+    postconditions: [
+      `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} is installed with the MCP extra`,
+      "headroom mcp serve --help succeeds"
+    ],
+    rollbackData: "package-inventory",
+    explanation: `Install reviewed Headroom ${HEADROOM_REVIEWED_MCP_VERSION} with its MCP extra through uv`,
+    packageManager: "uv",
+    packageName: "headroom-ai[mcp]",
+    version: HEADROOM_REVIEWED_MCP_VERSION
   };
 }
 function prerequisite(harness, detail2) {
@@ -19358,7 +19730,7 @@ function prerequisite(harness, detail2) {
         code: "headroom-managed-mcp-prerequisite",
         subject: harness,
         message: detail2,
-        remediation: `Install the exact reviewed Headroom ${HEADROOM_REVIEWED_MCP_VERSION} MCP package with your existing Python/uv tooling, then refresh Token Harness. Token Harness will not install Python, uv, or system prerequisites implicitly.`
+        remediation: `Install Headroom ${HEADROOM_REVIEWED_MCP_VERSION} or newer with its MCP extra using your existing Python/uv tooling, then refresh Token Harness. Token Harness will not install Python, uv, or system prerequisites implicitly.`
       })
     ]
   };
@@ -19612,9 +19984,9 @@ async function planCodex(context, harness) {
     affectedPaths: [target],
     affectedProcesses: [],
     preconditions: ["No Headroom MCP table or Token Harness Headroom marker block exists"],
-    postconditions: ["Codex config contains exactly one reviewed Headroom MCP server block"],
+    postconditions: ["Codex config contains exactly one Token Harness Headroom MCP server block"],
     rollbackData: "file-snapshot",
-    explanation: "Register the installed reviewed Headroom CLI as a Codex MCP server",
+    explanation: "Register the installed Headroom CLI as a Codex MCP server",
     path: target,
     markerBegin: HEADROOM_CODEX_MARKER_BEGIN,
     markerEnd: HEADROOM_CODEX_MARKER_END,
@@ -19643,10 +20015,25 @@ async function planHeadroomManagedMcpActivation(context, harness) {
       ]
     };
   }
-  const cli = await reviewedMcpCliAvailable(context);
-  if (!cli.ok)
-    return prerequisite(harness, cli.detail);
-  return harness === "claude" ? planClaude(context, harness) : planCodex(context, harness);
+  const cli = await headroomManagedMcpRuntime(context);
+  const installActions = [];
+  if (!cli.ok) {
+    const observation = await observeHeadroomCandidate(context);
+    if (observation.state !== "absent")
+      return prerequisite(harness, cli.detail);
+    const uv = await context.runner.run({
+      executable: "uv",
+      args: ["--version"],
+      cwd: context.projectRoot,
+      timeoutMs: 2e4
+    });
+    if (uv.failure !== null || uv.exitCode !== 0) {
+      return prerequisite(harness, "Headroom is absent and uv is not available in this terminal. Install uv or make it available on PATH; Token Harness will not bootstrap Python or uv itself.");
+    }
+    installActions.push(headroomInstallAction());
+  }
+  const activation = harness === "claude" ? await planClaude(context, harness) : await planCodex(context, harness);
+  return { ...activation, actions: [...installActions, ...activation.actions] };
 }
 function headroomOwnedArtifact(context, harness) {
   if (harness === "claude") {
@@ -19670,7 +20057,7 @@ function headroomOwnedArtifact(context, harness) {
   return null;
 }
 async function verifyHeadroomManagedMcpActivation(context, harness) {
-  const cli = await reviewedMcpCliAvailable(context);
+  const cli = await headroomManagedMcpRuntime(context);
   if (!cli.ok)
     return { state: "candidate-unavailable", target: null, detail: cli.detail };
   if (harness === "claude") {
@@ -19693,13 +20080,13 @@ async function verifyHeadroomManagedMcpActivation(context, harness) {
       return {
         state: "degraded",
         target,
-        detail: "Headroom MCP entry differs from the reviewed command"
+        detail: "Headroom MCP entry differs from the Token Harness managed command"
       };
     }
     return {
       state: "verified",
       target,
-      detail: `${cli.detail}; Claude registration matches the reviewed entry`
+      detail: `${cli.detail}; Claude registration matches the managed entry`
     };
   }
   if (harness === "codex") {
@@ -19719,12 +20106,12 @@ async function verifyHeadroomManagedMcpActivation(context, harness) {
       return {
         state: "not-configured",
         target,
-        detail: "Reviewed Headroom Codex MCP block is absent"
+        detail: "Token Harness Headroom Codex MCP block is absent"
       };
     return {
       state: "verified",
       target,
-      detail: `${cli.detail}; Codex registration matches the reviewed owned block`
+      detail: `${cli.detail}; Codex registration matches the managed owned block`
     };
   }
   return {
@@ -19760,30 +20147,38 @@ function manualInstallWarning() {
     severity: "warning",
     code: "headroom-uv-install-prerequisite",
     subject: "headroom",
-    message: `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} is not installed. Token Harness can manage its MCP configuration after the reviewed CLI is present.`,
-    remediation: `With your existing uv and a compatible system Python >=3.10, run: uv tool install --no-managed-python --no-python-downloads "headroom-ai[mcp]==${HEADROOM_REVIEWED_MCP_VERSION}". Token Harness does not install uv, Python, or admin prerequisites.`
+    message: `Headroom ${HEADROOM_REVIEWED_MCP_VERSION} or newer is not installed. Token Harness can manage its MCP configuration after a compatible CLI is present.`,
+    remediation: `With your existing uv and a compatible system Python >=3.10, install headroom-ai[mcp] ${HEADROOM_REVIEWED_MCP_VERSION} or newer. Token Harness does not install uv, Python, or admin prerequisites.`
   });
 }
 async function detect8(context) {
   const observation = await observeHeadroomCandidate(context);
+  const runtime = await headroomManagedMcpRuntime(context);
   const configuredHarnesses = [];
-  if (observation.version === HEADROOM_REVIEWED_MCP_VERSION) {
+  if (runtime.ok) {
     for (const harness of [CLAUDE7, CODEX4]) {
       const verification = await verifyHeadroomManagedMcpActivation(context, harness);
       if (verification.state === "verified")
         configuredHarnesses.push(harness);
     }
   }
+  const uv = observation.state === "absent" ? await context.runner.run({
+    executable: "uv",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  }) : null;
+  const canInstall = observation.state === "absent" && uv !== null && uv.failure === null && uv.exitCode === 0;
   const warnings = [];
-  if (observation.state === "absent")
+  if (observation.state === "absent" && !canInstall)
     warnings.push(manualInstallWarning());
-  if (observation.state === "unsupported-version") {
+  else if (!runtime.ok && observation.state !== "absent") {
     warnings.push(diagnostic({
       severity: "warning",
-      code: "headroom-provider-version-unreviewed",
+      code: "headroom-provider-capability-unavailable",
       subject: "headroom",
-      message: observation.reasons[0] ?? `The installed Headroom version is outside the reviewed ${HEADROOM_REVIEWED_MCP_VERSION} row.`,
-      remediation: `Keep that installation user-owned or use the exact reviewed ${HEADROOM_REVIEWED_MCP_VERSION} build.`
+      message: runtime.detail,
+      remediation: `Update Headroom to ${HEADROOM_REVIEWED_MCP_VERSION} or newer with the MCP extra, then refresh Token Harness.`
     }));
   }
   return {
@@ -19800,7 +20195,7 @@ async function detect8(context) {
     unmanagedHarnessesConfigured: [],
     supportsUnmanagedHarnesses: false,
     managedByTokenHarness: false,
-    assignableHarnesses: observation.version === HEADROOM_REVIEWED_MCP_VERSION ? [CLAUDE7, CODEX4] : [],
+    assignableHarnesses: runtime.ok || canInstall ? [CLAUDE7, CODEX4] : [],
     evidence: [],
     warnings
   };
@@ -19873,7 +20268,7 @@ async function verify8(context) {
       summary: result6.detail,
       achievedTier: result6.state === "verified" ? "config-only" : result6.state === "candidate-unavailable" ? null : "presence",
       evidence: [],
-      remediation: result6.state === "candidate-unavailable" ? `Install reviewed Headroom ${HEADROOM_REVIEWED_MCP_VERSION} with its MCP extra first.` : null
+      remediation: result6.state === "candidate-unavailable" ? `Install Headroom ${HEADROOM_REVIEWED_MCP_VERSION} or newer with its MCP extra first.` : null
     });
   }
   return {
@@ -20046,26 +20441,25 @@ var init_mcptoon_provider = __esm({
 
 // packages/adapters/dist/src/providers/version-compatibility.js
 function reviewedProviderPackageMaximum(provider) {
-  return REVIEWED_PACKAGE_UPDATE_RANGES.get(provider)?.maximum ?? null;
+  return PACKAGE_UPDATE_BASELINES.get(provider)?.maximum ?? null;
 }
 function admitProviderPackageUpdate(provider, targetVersion) {
-  const range = REVIEWED_PACKAGE_UPDATE_RANGES.get(provider);
+  const range = PACKAGE_UPDATE_BASELINES.get(provider);
   if (range === void 0) {
     return { state: "blocked", reason: `no package-update policy exists for ${provider}` };
   }
   const target = parseSemanticVersion(targetVersion);
   const minimum = parseSemanticVersion(range.minimum);
-  const maximum = parseSemanticVersion(range.maximum);
-  if (target === null || minimum === null || maximum === null) {
+  if (target === null || minimum === null) {
     return {
       state: "blocked",
-      reason: `${targetVersion} is not a parseable reviewed provider release`
+      reason: `${targetVersion} is not a parseable provider release`
     };
   }
-  if (compareVersions(target, minimum) < 0 || compareVersions(target, maximum) > 0) {
+  if (compareVersions(target, minimum) < 0) {
     return {
       state: "blocked",
-      reason: `${targetVersion} is outside the reviewed package-update range ${range.minimum}..${range.maximum}`
+      reason: `${targetVersion} predates the supported provider update floor ${range.minimum}`
     };
   }
   return { state: "admitted" };
@@ -20078,10 +20472,15 @@ function harnessTrimContractMatchesInstalledVersion(detection) {
   const capabilityDrift = detection.warnings.some((warning2) => warning2.code === "provider-capabilities-drift");
   return declaredByInstalledBuild && !capabilityDrift;
 }
+function runtimeManagedSurfaceStillAvailable(detection) {
+  if (detection.state === "broken" || detection.assignableHarnesses.length === 0)
+    return false;
+  return !detection.warnings.some((warning2) => /capabilit/i.test(warning2.code) && /(unavailable|drift|mismatch|unsupported)/i.test(warning2.code));
+}
 function applyProviderVersionCompatibility(detection) {
   if (detection.versionVerdict !== "unknown-newer" || detection.version === null)
     return detection;
-  const compatible = detection.providerId === RTK3 && SOURCE_REVIEWED_RTK_RELEASES.has(detection.version) || detection.providerId === HARNESSTRIM3 && harnessTrimContractMatchesInstalledVersion(detection);
+  const compatible = detection.providerId === HARNESSTRIM3 ? harnessTrimContractMatchesInstalledVersion(detection) : [RTK3, MCPTOON2, GITNEXUS2, HEADROOM3].includes(detection.providerId) && runtimeManagedSurfaceStillAvailable(detection);
   if (!compatible)
     return detection;
   return {
@@ -20096,17 +20495,40 @@ function withProviderVersionCompatibility(adapter) {
     detect: async (context) => applyProviderVersionCompatibility(await adapter.detect(context))
   };
 }
-var RTK3, HARNESSTRIM3, SOURCE_REVIEWED_RTK_RELEASES, REVIEWED_PACKAGE_UPDATE_RANGES;
+var RTK3, HARNESSTRIM3, MCPTOON2, GITNEXUS2, HEADROOM3, PACKAGE_UPDATE_BASELINES;
 var init_version_compatibility = __esm({
   "packages/adapters/dist/src/providers/version-compatibility.js"() {
     "use strict";
     init_src();
+    init_gitnexus_candidate();
+    init_headroom_candidate();
+    init_mcptoon_candidate();
     RTK3 = providerId("rtk");
     HARNESSTRIM3 = providerId("harnesstrim");
-    SOURCE_REVIEWED_RTK_RELEASES = /* @__PURE__ */ new Set(["0.49.0"]);
-    REVIEWED_PACKAGE_UPDATE_RANGES = /* @__PURE__ */ new Map([
+    MCPTOON2 = providerId("mcptoon");
+    GITNEXUS2 = providerId("gitnexus");
+    HEADROOM3 = providerId("headroom");
+    PACKAGE_UPDATE_BASELINES = /* @__PURE__ */ new Map([
       [RTK3, { minimum: "0.44.0", maximum: "0.49.0" }],
-      [HARNESSTRIM3, { minimum: "0.0.5", maximum: "0.3.0" }]
+      [HARNESSTRIM3, { minimum: "0.0.5", maximum: "0.3.0" }],
+      [
+        MCPTOON2,
+        { minimum: MCPTOON_REVIEWED_BENCHMARK_VERSION, maximum: MCPTOON_REVIEWED_BENCHMARK_VERSION }
+      ],
+      [
+        GITNEXUS2,
+        {
+          minimum: GITNEXUS_REVIEWED_BENCHMARK_VERSION,
+          maximum: GITNEXUS_REVIEWED_BENCHMARK_VERSION
+        }
+      ],
+      [
+        HEADROOM3,
+        {
+          minimum: HEADROOM_REVIEWED_BENCHMARK_VERSION,
+          maximum: HEADROOM_REVIEWED_BENCHMARK_VERSION
+        }
+      ]
     ]);
   }
 });
@@ -20303,9 +20725,9 @@ var init_providers = __esm({
     PROVIDER_ADAPTERS = [
       rtkAdapter2,
       cliHarnessTrimAdapter,
-      mcptoonManagedProviderAdapter,
-      gitnexusManagedProviderAdapter,
-      headroomManagedProviderAdapter
+      withProviderVersionCompatibility(mcptoonManagedProviderAdapter),
+      withProviderVersionCompatibility(gitnexusManagedProviderAdapter),
+      withProviderVersionCompatibility(headroomManagedProviderAdapter)
     ];
   }
 });
@@ -21224,6 +21646,33 @@ var init_candidate_campaign_surface = __esm({
   }
 });
 
+// apps/cli/dist/src/commands/snapshot-safety.js
+async function repositoryRootForBackupSafety(context) {
+  const adapters = context.adapters;
+  if (adapters === null)
+    return context.projectRoot;
+  const fs = adapters.fs;
+  let current = context.projectRoot;
+  while (true) {
+    for (const marker of [".git", ".hg", ".svn"]) {
+      if (await fs.stat(fs.join(current, marker)) !== null)
+        return current;
+    }
+    if (context.home !== null && fs.isInside(current, context.home) && fs.isInside(context.home, current)) {
+      return null;
+    }
+    const parent = fs.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+var init_snapshot_safety = __esm({
+  "apps/cli/dist/src/commands/snapshot-safety.js"() {
+    "use strict";
+  }
+});
+
 // apps/cli/dist/src/commands/gitnexus-candidate-lifecycle.js
 function emptyReport(outcome2, requestedStateVerified = false) {
   return {
@@ -21285,7 +21734,7 @@ function selectorProblem(context, command) {
   }
   return null;
 }
-function stores(context, id) {
+async function stores(context, id) {
   if (context.adapters === null || context.stateRoot === null)
     return null;
   const fs = context.adapters.fs;
@@ -21293,7 +21742,7 @@ function stores(context, id) {
     fs,
     backupRoot: fs.join(context.stateRoot, "backups"),
     transactionId: id,
-    projectRoot: context.projectRoot,
+    projectRoot: await repositoryRootForBackupSafety(context),
     now: context.now
   });
   if (!creation.ok)
@@ -21486,7 +21935,7 @@ async function runGitNexusCandidateApply(context) {
     return finish("apply", EXIT_CODES["confirmation-required"], emptyReport("confirmation-required"), diagnostics);
   }
   const id = transactionId("gitnexus-activate-claude", context);
-  const built = stores(context, id);
+  const built = await stores(context, id);
   if (built === null || !("snapshots" in built)) {
     diagnostics.push(...built?.failure ?? []);
     return finish("apply", EXIT_CODES["unsupported-environment"], emptyReport("rejected"), diagnostics);
@@ -21592,7 +22041,7 @@ async function runGitNexusCandidateUninstall(context) {
     return finish("uninstall", EXIT_CODES["confirmation-required"], emptyReport("confirmation-required"), diagnostics);
   }
   const id = transactionId("gitnexus-deactivate-claude", context);
-  const built = stores(context, id);
+  const built = await stores(context, id);
   if (built === null || !("snapshots" in built)) {
     diagnostics.push(...built?.failure ?? []);
     return finish("uninstall", EXIT_CODES["unsupported-environment"], emptyReport("rejected"), diagnostics);
@@ -21632,6 +22081,7 @@ var init_gitnexus_candidate_lifecycle = __esm({
     init_src3();
     init_src();
     init_candidate_campaign_surface();
+    init_snapshot_safety();
     ACTIVATION_ACTION_ID = "gitnexus:claude:mcp-server";
     REMOVAL_ACTION_ID = "gitnexus:claude:mcp-server:remove";
     REVIEWED_VALUE_DIGEST = jsonValueDigest(GITNEXUS_MCP_SERVER);
@@ -21709,7 +22159,7 @@ function selectorProblem2(context, command) {
   }
   return null;
 }
-function stores2(context, transactionId2) {
+async function stores2(context, transactionId2) {
   if (context.adapters === null || context.stateRoot === null)
     return null;
   const fs = context.adapters.fs;
@@ -21717,7 +22167,7 @@ function stores2(context, transactionId2) {
     fs,
     backupRoot: fs.join(context.stateRoot, "backups"),
     transactionId: transactionId2,
-    projectRoot: context.projectRoot,
+    projectRoot: await repositoryRootForBackupSafety(context),
     now: context.now
   });
   if (!creation.ok)
@@ -21808,7 +22258,7 @@ async function runCandidateApply(context) {
     return finish2("apply", EXIT_CODES["confirmation-required"], emptyReport2("confirmation-required"), diagnostics);
   }
   const transactionId2 = candidateTransactionId(`mcptoon-activate-${harness}`, context);
-  const built = stores2(context, transactionId2);
+  const built = await stores2(context, transactionId2);
   if (built === null || !("snapshots" in built)) {
     diagnostics.push(...built?.failure ?? []);
     return finish2("apply", EXIT_CODES["unsupported-environment"], emptyReport2("rejected"), diagnostics);
@@ -21953,7 +22403,7 @@ async function runCandidateUninstall(context) {
     return finish2("uninstall", EXIT_CODES["confirmation-required"], emptyReport2("confirmation-required"), diagnostics);
   }
   const transactionId2 = candidateTransactionId(`mcptoon-deactivate-${harness}`, context);
-  const built = stores2(context, transactionId2);
+  const built = await stores2(context, transactionId2);
   if (built === null || !("snapshots" in built)) {
     diagnostics.push(...built?.failure ?? []);
     return finish2("uninstall", EXIT_CODES["unsupported-environment"], emptyReport2("rejected"), diagnostics);
@@ -21998,6 +22448,7 @@ var init_mcptoon_candidate_lifecycle = __esm({
     init_src3();
     init_src();
     init_candidate_campaign_surface();
+    init_snapshot_safety();
   }
 });
 
@@ -24056,6 +24507,17 @@ async function computePlan(context) {
           wsl: context.platform.isWsl
         });
         if (admission.state !== "admitted") {
+          const dynamicallyAssignable = assignable.get(adapter.manifest.id)?.has(harness) === true;
+          if (dynamicallyAssignable) {
+            diagnostics.push(diagnostic({
+              severity: "info",
+              code: "managed-mutation-forward-compatible",
+              subject: adapter.manifest.id,
+              message: `${adapter.manifest.displayName} declares that it can configure ${harness} on the installed build. Token Harness will use the normal transactional apply path and verify the resulting state even though this exact version tuple is newer than the recorded compatibility evidence.`,
+              remediation: null
+            }));
+            continue;
+          }
           admitted = false;
           blocked.push({
             provider: adapter.manifest.id,
@@ -24224,7 +24686,7 @@ async function computePlan(context) {
       severity: refusalIsTheOutcome ? "error" : "warning",
       code: "managed-mutation-blocked",
       message: `plan refuses managed mutation of ${entry.harness} by ${entry.provider}${entry.providerVersion !== null ? ` at ${entry.providerVersion}` : ""}: ${entry.missing}`,
-      remediation: "Add a compatibility row whose fixture proves this combination, or configure this integration by hand"
+      remediation: "Restore the provider runtime capability required for this managed integration, or configure it by hand"
     }));
   }
   for (const conflict of conflicts) {
@@ -24303,6 +24765,73 @@ var init_plan2 = __esm({
 });
 
 // apps/cli/dist/src/commands/apply.js
+async function verifyManagedIntegrationPostconditions(context, integrations) {
+  if (integrations.length === 0)
+    return [];
+  if (context.adapters === null) {
+    return [
+      diagnostic({
+        severity: "error",
+        code: "managed-setup-postcondition-unavailable",
+        message: "The managed integration could not be re-observed because platform adapters are unavailable",
+        remediation: "Refresh the current setup before retrying"
+      })
+    ];
+  }
+  const detectionContext = {
+    fs: context.adapters.fs,
+    runner: context.adapters.runner,
+    facts: context.platform,
+    paths: context.adapters.paths,
+    projectRoot: context.projectRoot
+  };
+  const harnessConfigs = (await Promise.all(listHarnessAdapters().map(async (adapter) => (await adapter.inspect(detectionContext)).summaries))).flat();
+  const providerContext4 = {
+    ...detectionContext,
+    harnessConfigs,
+    now: context.now,
+    localDatabase: context.adapters.localDatabase,
+    projectIdFor: context.adapters.projectIdFor
+  };
+  const adapters = new Map(listProviderAdapters().map((adapter) => [adapter.manifest.id, adapter]));
+  const diagnostics = [];
+  for (const integration of integrations) {
+    const adapter = adapters.get(integration.providerId);
+    if (adapter === void 0) {
+      diagnostics.push(diagnostic({
+        severity: "error",
+        code: "managed-setup-postcondition-unavailable",
+        subject: integration.providerId,
+        message: `The provider adapter disappeared before ${integration.harnessId} setup could be verified`,
+        remediation: "Refresh Token Harness and review a new setup preview"
+      }));
+      continue;
+    }
+    try {
+      const detection = await adapter.detect(providerContext4);
+      if (!detection.configuredHarnesses.some((harness) => harness === integration.harnessId)) {
+        const runtimeProblem = detection.warnings.find((entry) => entry.severity === "error" || entry.severity === "warning");
+        diagnostics.push(diagnostic({
+          severity: "error",
+          code: "managed-setup-postcondition-unmet",
+          subject: integration.providerId,
+          message: `${adapter.manifest.displayName} setup did not become active for ${integration.harnessId} after the approved actions` + (runtimeProblem === void 0 ? "" : `: ${runtimeProblem.message}`),
+          path: detection.executable,
+          remediation: runtimeProblem?.remediation ?? "Check that the newly installed provider executable is on PATH, then review a fresh setup preview"
+        }));
+      }
+    } catch (error) {
+      diagnostics.push(diagnostic({
+        severity: "error",
+        code: "managed-setup-postcondition-unavailable",
+        subject: integration.providerId,
+        message: `The provider could not be re-observed after setup: ${error instanceof Error ? error.message : String(error)}`,
+        remediation: "Refresh and inspect the provider runtime before retrying"
+      }));
+    }
+  }
+  return diagnostics;
+}
 function transactionIdFor(planId, at) {
   const digest = digestText(`${planId} ${at}`);
   return digest.slice(digest.indexOf(":") + 1, digest.indexOf(":") + 13);
@@ -24522,7 +25051,7 @@ async function runApply(context) {
     fs,
     backupRoot: fs.join(context.stateRoot, "backups"),
     transactionId: transactionId2,
-    projectRoot: context.projectRoot,
+    projectRoot: await repositoryRootForBackupSafety(context),
     now: context.now
   });
   if (!creation.ok) {
@@ -24552,7 +25081,8 @@ async function runApply(context) {
     journal,
     // RFC 0004 §Process policy: an installer reaches the machine through the runner or not at all.
     runner: context.adapters.runner,
-    now: context.now
+    now: context.now,
+    verifyPostconditions: async () => verifyManagedIntegrationPostconditions(context, computed.managedIntegrations)
   });
   diagnostics.push(...transaction.diagnostics);
   const report = {
@@ -24587,8 +25117,10 @@ var init_apply = __esm({
   "apps/cli/dist/src/commands/apply.js"() {
     "use strict";
     init_src();
+    init_src3();
     init_candidate_lifecycle();
     init_plan2();
+    init_snapshot_safety();
     PLANS_DIRECTORY = "plans";
   }
 });
@@ -26864,7 +27396,7 @@ async function runDoctor(context) {
       ]
     };
   });
-  const problemCount = harnesses.filter(isBroken).length + providers.filter(isBroken).length + [...harnesses, ...providers].filter((detection) => detection.versionVerdict === "unknown-newer").length;
+  const problemCount = harnesses.filter(isBroken).length + providers.filter(isBroken).length;
   const rows = context.compatibilityRows ?? COMPATIBILITY_ROWS;
   const providersWithCoverage = providersWithPathDiagnostics.map((detection) => {
     if (detection.state !== "configured" || detection.configuredHarnesses.length === 0) {
@@ -26880,14 +27412,14 @@ async function runDoctor(context) {
         os: context.platform.os,
         wsl: context.platform.isWsl
       });
-      if (admission.state === "admitted")
+      if (admission.state === "admitted" || detection.assignableHarnesses.includes(harness))
         return [];
       return [
         diagnostic({
           severity: "warning",
-          code: "no-compatibility-row",
-          message: `no compatibility row covers ${detection.providerId} on ${harness}${detection.version !== null ? ` at ${detection.version}` : ""} \u2014 ${admission.missing}`,
-          remediation: "Add a compatibility row whose fixture proves this combination, or configure this integration by hand"
+          code: "provider-surface-not-assignable",
+          message: `${detection.providerId} is configured on ${harness}, but the currently installed provider build does not advertise that harness as an automatic setup target`,
+          remediation: "Run the provider verification checks; keep the existing configuration if it is healthy, or update the provider if its automatic setup contract has changed"
         })
       ];
     });
@@ -27337,7 +27869,7 @@ function finish4(exitCode, command, data, diagnostics) {
     diagnostics
   });
 }
-function stores3(context, transactionId2) {
+async function stores3(context, transactionId2) {
   if (context.adapters === null || context.stateRoot === null)
     return null;
   const fs = context.adapters.fs;
@@ -27345,7 +27877,7 @@ function stores3(context, transactionId2) {
     fs,
     backupRoot: fs.join(context.stateRoot, "backups"),
     transactionId: transactionId2,
-    projectRoot: context.projectRoot,
+    projectRoot: await repositoryRootForBackupSafety(context),
     now: context.now
   });
   if (!creation.ok)
@@ -27420,7 +27952,7 @@ async function runRollback(context) {
     }));
     return finish4(EXIT_CODES["confirmation-required"], "rollback", empty("confirmation-required"), diagnostics);
   }
-  const built = stores3(context, target.transactionId);
+  const built = await stores3(context, target.transactionId);
   if (built === null || built.store === void 0) {
     diagnostics.push(...built?.failure ?? []);
     return finish4(EXIT_CODES["unsupported-environment"], "rollback", empty("rejected"), diagnostics);
@@ -27548,7 +28080,7 @@ async function runUninstall(context) {
   }
   const fs = context.adapters.fs;
   const transactionId2 = `uninstall-${context.now().replace(/[^0-9]/g, "").slice(0, 14)}`;
-  const built = stores3(context, transactionId2);
+  const built = await stores3(context, transactionId2);
   if (built === null || built.store === void 0) {
     diagnostics.push(...built?.failure ?? []);
     return finish4(EXIT_CODES["unsupported-environment"], "uninstall", empty("rejected"), diagnostics);
@@ -27584,6 +28116,7 @@ var init_rollback = __esm({
     init_src();
     init_candidate_lifecycle();
     init_plan2();
+    init_snapshot_safety();
   }
 });
 
@@ -28104,6 +28637,7 @@ async function runPackageChannelUpdate(context, options = {}) {
     projectIdFor: adapters.projectIdFor
   };
   const actions = [];
+  const updateTargets = /* @__PURE__ */ new Map();
   const blockedUpdates = [];
   const destinations = /* @__PURE__ */ new Set();
   for (const adapter of providerAdapters) {
@@ -28180,7 +28714,7 @@ async function runPackageChannelUpdate(context, options = {}) {
     }
     row2.verdict = "upgradable";
     report.providers.push(row2);
-    actions.push(upgradeAction({
+    const action = upgradeAction({
       providerId: adapter.manifest.id,
       channel: channel.id,
       packageName,
@@ -28188,15 +28722,23 @@ async function runPackageChannelUpdate(context, options = {}) {
       requiresNetwork: channel.requiresNetwork,
       requiresElevation: channel.requiresElevation,
       installed: detection.version ?? "an unknown version"
-    }));
+    });
+    actions.push(action);
+    updateTargets.set(action.id, {
+      providerId: adapter.manifest.id,
+      target: query.version,
+      channel: channel.id,
+      packageName,
+      adapter
+    });
   }
   report.network = [...destinations].sort();
   for (const blocked of blockedUpdates) {
     diagnostics.push(diagnostic({
       severity: "info",
       code: "provider-update-target-unreviewed",
-      message: `${blocked.providerId} ${blocked.target} is available but is outside the reviewed provider package-update policy; keeping ${blocked.installed ?? "the installed version"}`,
-      remediation: "Review the provider package contract before enabling unattended update to this release"
+      message: `${blocked.providerId} ${blocked.target} is available but does not meet the provider update prerequisites; keeping ${blocked.installed ?? "the installed version"}`,
+      remediation: "Check the provider update floor or version format, then retry the update"
     }));
     diagnostics.push(diagnostic({
       severity: "info",
@@ -28248,7 +28790,7 @@ async function runPackageChannelUpdate(context, options = {}) {
     fs,
     backupRoot: fs.join(context.stateRoot, "backups"),
     transactionId: transactionId2,
-    projectRoot: context.projectRoot,
+    projectRoot: await repositoryRootForBackupSafety(context),
     now: context.now
   });
   if (!creation.ok) {
@@ -28269,7 +28811,78 @@ async function runPackageChannelUpdate(context, options = {}) {
       backupRoot: fs.join(context.stateRoot, "backups")
     }),
     runner: adapters.runner,
-    now: context.now
+    now: context.now,
+    verifyPostconditions: async (applied) => {
+      const postconditions = [];
+      for (const outcome2 of applied) {
+        if (outcome2.status !== "applied" && outcome2.status !== "already-satisfied")
+          continue;
+        const target = updateTargets.get(outcome2.actionId);
+        if (target === void 0)
+          continue;
+        const detection = await target.adapter.detect(providerContext4);
+        const observed = detection.version === null ? null : parseSemanticVersion(detection.version);
+        const expected = parseSemanticVersion(target.target);
+        const exactTarget = observed !== null && expected !== null && compareVersions(observed, expected) === 0;
+        if (!exactTarget) {
+          const inventory = await queryPackageInventory({
+            channel: target.channel,
+            packageName: target.packageName,
+            runner: adapters.runner,
+            cwd: context.projectRoot
+          });
+          const inventoryDetail = inventory.status === "captured" && inventory.version !== null ? ` The ${target.channel} global inventory reports ${inventory.version}.` : ` The ${target.channel} inventory could not confirm the installed target (status: ${inventory.status}).`;
+          const prefix = target.channel === "npm" ? await adapters.runner.run({
+            executable: "npm",
+            args: ["config", "get", "prefix"],
+            cwd: context.projectRoot,
+            timeoutMs: 2e4
+          }) : null;
+          const prefixDetail = prefix !== null && prefix.failure === null && prefix.exitCode === 0 ? ` npm prefix: ${prefix.stdout.trim() || "(empty)"}.` : "";
+          postconditions.push(diagnostic({
+            severity: "error",
+            code: "provider-update-version-not-observed",
+            subject: target.adapter.manifest.id,
+            message: `${target.providerId} update did not become active: requested ${target.target}, but the executable currently resolved on PATH reports ${detection.version ?? "no readable version"}.` + inventoryDetail + prefixDetail,
+            path: detection.executable,
+            remediation: "Review duplicate PATH installations and the package-manager global prefix. Token Harness will not report this update as successful while the requested runtime is not the one being resolved."
+          }));
+          continue;
+        }
+        const capabilityProblem = detection.warnings.find((warning2) => /capabilit/i.test(warning2.code) && /(unavailable|drift|mismatch|unsupported)/i.test(warning2.code));
+        if (target.adapter.manifest.id === "harnesstrim" && (detection.versionVerdict !== "in-range" || capabilityProblem !== void 0)) {
+          postconditions.push(diagnostic({
+            severity: "error",
+            code: "harnesstrim-update-contract-mismatch",
+            subject: target.adapter.manifest.id,
+            message: `HarnessTrim ${target.target} was installed, but its machine-readable capability/artifact contract did not pass Token Harness validation` + (capabilityProblem === void 0 ? "" : `: ${capabilityProblem.message}`),
+            path: detection.executable,
+            remediation: "Keep the previous working HarnessTrim release until the changed contract is understood."
+          }));
+          continue;
+        }
+        if (["mcptoon", "gitnexus", "headroom"].includes(target.adapter.manifest.id) && (detection.assignableHarnesses.length === 0 || capabilityProblem !== void 0)) {
+          postconditions.push(diagnostic({
+            severity: "error",
+            code: "provider-update-capability-unavailable",
+            subject: target.adapter.manifest.id,
+            message: `${target.providerId} ${target.target} became active on PATH, but the installed build no longer exposes the runtime capability surface required by Token Harness` + (capabilityProblem === void 0 ? "" : `: ${capabilityProblem.message}`),
+            path: detection.executable,
+            remediation: "Keep the previous working provider release until the changed CLI capability surface is understood."
+          }));
+          continue;
+        }
+        postconditions.push(diagnostic({
+          severity: "info",
+          code: "provider-update-version-verified",
+          subject: target.adapter.manifest.id,
+          message: `${target.providerId} ${target.target} is now the executable resolved on PATH and passed post-update detection`,
+          path: detection.executable,
+          remediation: null
+        }));
+      }
+      return postconditions;
+    }
   });
   diagnostics.push(...transaction.diagnostics);
   report.execution = {
@@ -28304,6 +28917,7 @@ var init_update_base = __esm({
     "use strict";
     init_src();
     init_src3();
+    init_snapshot_safety();
   }
 });
 
@@ -28564,7 +29178,7 @@ async function runUpdate(context) {
     fs,
     backupRoot: fs.join(context.stateRoot, "backups"),
     transactionId: transactionId2,
-    projectRoot: context.projectRoot,
+    projectRoot: await repositoryRootForBackupSafety(context),
     now: context.now
   });
   if (!snapshotCreation.ok) {
@@ -28847,6 +29461,7 @@ var init_update = __esm({
     "use strict";
     init_src();
     init_src2();
+    init_snapshot_safety();
     init_update_base();
     init_rtk_release_update();
   }
@@ -31998,21 +32613,21 @@ function guideSetupTarget(report, harness, provider) {
       reason: `${label} is configured for ${name(harness)}.`
     };
   }
-  const hasReviewedHarnessSurface = COMPATIBILITY_ROWS.some((row2) => row2.provider === provider && row2.harness === harnessDetection.harnessId);
-  if (!hasReviewedHarnessSurface) {
-    return {
-      providerId: provider,
-      provider: label,
-      state: "not-applicable",
-      reason: `Token Harness does not manage a reviewed ${label} connection for ${name(harness)}.`
-    };
-  }
   if (detection.state === "absent" || detection.state === "available") {
+    if (detection.assignableHarnesses.includes(harnessDetection.harnessId)) {
+      return {
+        providerId: provider,
+        provider: label,
+        state: "actionable",
+        reason: `${label} is not installed yet, but Token Harness has a reviewed automatic install + ${name(harness)} setup path. The exact package and configuration changes are shown before approval.`
+      };
+    }
+    const prerequisite2 = detection.warnings.find((entry) => entry.severity === "warning" || entry.severity === "error");
     return {
       providerId: provider,
       provider: label,
       state: "unavailable",
-      reason: `${label} is not installed in a state Token Harness can configure automatically.`
+      reason: prerequisite2 === void 0 ? `${label} is not installed and no automatic installer prerequisite is available in this terminal.` : `${prerequisite2.message}${prerequisite2.remediation === null ? "" : ` ${prerequisite2.remediation}`}`
     };
   }
   if (detection.state === "broken") {
@@ -32024,34 +32639,19 @@ function guideSetupTarget(report, harness, provider) {
     };
   }
   if (!detection.assignableHarnesses.includes(harnessDetection.harnessId)) {
+    const capability = detection.warnings.find((entry) => entry.severity === "warning" || entry.severity === "error");
     return {
       providerId: provider,
       provider: label,
-      state: "unavailable",
-      reason: `The installed ${label} build does not expose a reviewed automatic setup for ${name(harness)}.`
-    };
-  }
-  const admission = admitManagedMutation(COMPATIBILITY_ROWS, {
-    provider: detection.providerId,
-    providerVersion: detection.version,
-    harness: harnessDetection.harnessId,
-    harnessVersion: harnessDetection.version,
-    os: report.platform.os,
-    wsl: report.platform.isWsl
-  });
-  if (admission.state !== "admitted") {
-    return {
-      providerId: provider,
-      provider: label,
-      state: "unavailable",
-      reason: `Automatic ${label} setup is not reviewed for the installed ${name(harness)} / ${label} version combination on ${report.platform.os}.`
+      state: "not-applicable",
+      reason: capability === void 0 ? `The installed ${label} build does not expose an automatic ${name(harness)} setup surface.` : `${capability.message}${capability.remediation === null ? "" : ` ${capability.remediation}`}`
     };
   }
   return {
     providerId: provider,
     provider: label,
     state: "actionable",
-    reason: `${label} can be configured automatically for ${name(harness)} with the reviewed transaction path.`
+    reason: `${label} can be configured automatically for ${name(harness)}. Token Harness will apply it transactionally and re-check the resulting state.`
   };
 }
 function guideSetupTargets(report, harness) {
@@ -32063,7 +32663,7 @@ function explainGuideIssue(diagnostics, fallback) {
     return ISSUE_COPY[known.code];
   const blocked = diagnostics.find((entry) => /compatibility|unsupported|unreviewed|no-row/.test(entry.code));
   if (blocked !== void 0)
-    return "Automatic changes are not verified for this version combination. Your current settings are preserved.";
+    return "The required automatic capability or safety precondition is not available in the current runtime. Your current settings are preserved.";
   if (diagnostics.some((entry) => /drift|mismatch|precondition|conflict/.test(entry.code)))
     return "Something changed since the preview. No unsafe change was made. Review the current setup again.";
   return fallback;
@@ -32089,7 +32689,7 @@ function stackFingerprint(report) {
 function createGuideCall(base) {
   return async (args) => {
     const savings = args[0] === "savings";
-    const updateCheck = args[0] === "update";
+    const updateCheck = args[0] === "update" && !args.includes("--yes");
     const translated = savings ? ["metrics", ...args.slice(1)] : [...args];
     let stdout = "";
     await run({
@@ -32300,7 +32900,7 @@ function describeChange(action, harness) {
     files: action.affectedPaths.length
   };
 }
-var GuideError, NAMES, name, GUIDE_MANAGED_PROVIDERS, RECOMMENDED_SETUP_PROVIDERS, TASKS, PERIODS, STACK_COMPONENTS, ISSUE_COPY, EFFORT_LABELS, SAFETY_RULES, TASK_RULES, READ_STAGES, GuideService;
+var GuideError, NAMES, name, sameGuideVersion, GUIDE_MANAGED_PROVIDERS, RECOMMENDED_SETUP_PROVIDERS, TASKS, PERIODS, STACK_COMPONENTS, ISSUE_COPY, EFFORT_LABELS, SAFETY_RULES, TASK_RULES, READ_STAGES, GuideService;
 var init_guided = __esm({
   "apps/cli/dist/src/guided.js"() {
     "use strict";
@@ -32328,6 +32928,7 @@ var init_guided = __esm({
       headroom: "Headroom"
     };
     name = (id) => NAMES[id] ?? id;
+    sameGuideVersion = (left, right) => left !== null && right !== null && left.replace(/^v/i, "").trim() === right.replace(/^v/i, "").trim();
     GUIDE_MANAGED_PROVIDERS = [
       "rtk",
       "harnesstrim",
@@ -32373,13 +32974,19 @@ var init_guided = __esm({
       "cclimits-claude-token-expired": "The Claude login has expired. Sign in again in Claude, then refresh.",
       "cclimits-claude-cache-stale": "Only old Claude allowance data was found. It is not presented as current allowance.",
       "cclimits-claude-source-unsupported": "This cclimits response lacks supported Claude discovery information. Check its installed version.",
-      "claude-native-policy-blocked": "Claude settings could not be changed safely. A project override, environment setting or unreviewed version may be in effect. Your settings were kept.",
-      "native-policy-harness-unsupported": "This agent does not expose a reviewed setting for this action.",
+      "claude-native-policy-blocked": "Claude settings could not be changed safely. A project override, environment setting or changed writable surface may be in effect. Your settings were kept.",
+      "native-policy-harness-unsupported": "This agent does not expose a writable setting surface for this action.",
       "codex-native-policy-unavailable": "Codex did not expose a writable, versioned user setting. No change is proposed.",
       "codex-native-policy-shadowed": "A project or profile overrides this Codex setting. That setting belongs to you and will not be replaced.",
       "no-providers-registered": "No optimization provider was selected for this operation.",
       "already-in-desired-state": "The supported integration is already configured. Nothing needs to be changed.",
-      "managed-mutation-unsupported": "Automatic setup is not yet verified for this installed version combination. Existing integrations are left untouched.",
+      "delegated-install-snapshot-too-large": "The optimizer setup found too much unrelated data inside its rollback boundary. Nothing was changed. Update Token Harness or use a narrower project directory before retrying.",
+      "delegated-install-failed": "The optimizer installer itself did not complete successfully. Nothing was kept from the failed transaction.",
+      "delegated-install-artifact-mismatch": "The optimizer installer completed but did not produce the artifact contract it advertised. The transaction was rolled back.",
+      "delegated-install-protected-path-changed": "The optimizer installer touched a file this setup promised to leave alone. The transaction was rolled back.",
+      "delegated-install-undeclared-write": "The optimizer installer changed a path outside the approved write set. The transaction was rolled back.",
+      "action-precondition-drift": "A file changed after the preview was created. Review a fresh preview before applying anything.",
+      "managed-mutation-unsupported": "Automatic setup is unavailable because the installed provider does not expose the required managed surface. Existing integrations are left untouched.",
       "plan-ownership-drift": "The integration changed after the preview. Review a fresh plan; nothing was forced.",
       "plan-version-drift": "An installed version changed after the preview. Review a fresh plan.",
       "plan-project-mismatch": "This preview belongs to a different project. Open a new preview here.",
@@ -32515,7 +33122,7 @@ var init_guided = __esm({
         if (this.busy && this.cached !== null)
           return this.cached.value;
         if (this.busy)
-          throw new GuideError(409, "A reviewed change is in progress.");
+          throw new GuideError(409, "Another managed change is in progress.");
         if (this.cached?.period === period && this.now() - this.cached.at < 15e3)
           return this.cached.value;
         if (this.reading !== null) {
@@ -32649,7 +33256,7 @@ var init_guided = __esm({
             name: name(agent.harnessId),
             version: agent.version,
             configured: providers.length > 0,
-            state: agent.state === "broken" ? "Needs attention" : providers.length > 0 ? "Integration configured" : hasActionableSetup ? "Ready to set up" : "No reviewed automatic setup available",
+            state: agent.state === "broken" ? "Needs attention" : providers.length > 0 ? "Integration configured" : hasActionableSetup ? "Ready to set up" : "No automatic setup surface available",
             providers: providers.map(name),
             setup,
             effort: observed?.nativeEffort?.current ?? observed?.reasoningEffort ?? null,
@@ -32925,59 +33532,147 @@ var init_guided = __esm({
       }
       async apply(input) {
         if (input === null || typeof input !== "object" || Array.isArray(input))
-          throw new GuideError(400, "A reviewed preview is required.");
+          throw new GuideError(400, "A current preview is required.");
         const data = input;
         if (Object.keys(data).length !== 1 || typeof data["ticket"] !== "string")
-          throw new GuideError(400, "A reviewed preview is required.");
+          throw new GuideError(400, "A current preview is required.");
         return this.exclusive(async () => {
           const approval = this.approval;
           if (approval === null || approval.id !== data["ticket"] || this.now() >= approval.expires)
             throw new GuideError(409, "This preview expired or was already used. Review a fresh preview.");
           this.approval = null;
           if (approval.operation === "update") {
-            this.record("Installing only the reviewed provider updates you approved.", "working");
-            let result6;
+            const approvedUpdates = approval.updateTargets ?? [];
+            if (approvedUpdates.length === 0)
+              throw new GuideError(409, "This update preview contains no concrete provider version. Review it again.");
+            this.record("Re-checking the exact provider versions you approved before installing them.", "working");
+            let fresh;
             try {
-              result6 = await this.call(["update", "--yes"]);
+              fresh = await this.call(["update"]);
             } catch {
               this.invalidateObservedState();
-              const message = "The update stopped before its final result could be read. No automatic retry was made. Refresh and inspect the installed optimizer versions before retrying.";
+              const message = "The update channels could not be re-checked immediately before installation. Nothing was changed. Review a fresh update preview.";
               this.record(message, "attention");
               return {
                 ok: false,
-                title: "Update result needs checking",
+                title: "Update preview changed",
                 messages: [message],
                 appliedPlans: 0
               };
             }
-            if (result6.exitCode !== 0 || result6.data === null) {
-              const message = explainGuideIssue(result6.diagnostics, "The reviewed optimizer update was not applied. The installed version, update channel or compatibility evidence changed after the preview, so nothing was forced.");
+            if (fresh.exitCode !== 0 || fresh.data === null) {
+              const message = explainGuideIssue(fresh.diagnostics, "The update channels changed or could not be re-checked after approval. Nothing was changed; review a fresh update preview.");
               this.invalidateObservedState();
               this.record(message, "attention");
               return {
                 ok: false,
-                title: "Optimizer update was not applied",
+                title: "Update preview changed",
                 messages: [message],
                 appliedPlans: 0
               };
             }
-            const applied = result6.data.execution?.results.filter((row2) => row2.status === "applied") ?? [];
+            const approvedByProvider = new Map(approvedUpdates.map((target) => [String(target.provider), target.version]));
+            const freshUpgradable = fresh.data.providers.filter((row2) => row2.verdict === "upgradable");
+            const unexpected = freshUpgradable.find((row2) => {
+              const approved = approvedByProvider.get(String(row2.providerId)) ?? null;
+              return approved === null || !sameGuideVersion(row2.available, approved);
+            });
+            const unresolved = approvedUpdates.find((target) => {
+              const row2 = fresh.data?.providers.find((candidate) => candidate.providerId === target.provider);
+              return !(row2 !== void 0 && (row2.verdict === "upgradable" && sameGuideVersion(row2.available, target.version) || row2.verdict === "current" && sameGuideVersion(row2.installed, target.version)));
+            });
+            if (unexpected !== void 0 || unresolved !== void 0) {
+              const changed = unexpected !== void 0 ? `${name(unexpected.providerId)} now offers ${unexpected.available ?? "a different version"}.` : `${name(unresolved.provider)} no longer reports the approved target ${unresolved.version}.`;
+              const message = changed + " Nothing was installed because the live update state no longer matches the preview. Review a fresh update preview.";
+              this.invalidateObservedState();
+              this.record(message, "attention");
+              return {
+                ok: false,
+                title: "Update preview changed",
+                messages: [message],
+                appliedPlans: 0
+              };
+            }
+            const pending = approvedUpdates.filter((target) => {
+              const row2 = fresh.data?.providers.find((candidate) => candidate.providerId === target.provider);
+              return row2?.verdict === "upgradable";
+            });
+            let appliedCount = 0;
+            if (pending.length > 0) {
+              this.record("Installing the provider versions from the approved preview.", "working");
+              let result6;
+              try {
+                result6 = await this.call(["update", "--yes"]);
+              } catch {
+                this.invalidateObservedState();
+                const message = "The update stopped before its final result could be read. No automatic retry was made. Refresh and inspect the installed optimizer versions before retrying.";
+                this.record(message, "attention");
+                return {
+                  ok: false,
+                  title: "Update result needs checking",
+                  messages: [message],
+                  appliedPlans: 0
+                };
+              }
+              if (result6.exitCode !== 0 || result6.data === null) {
+                const message = explainGuideIssue(result6.diagnostics, "The optimizer update was not applied. The installed version, update channel or runtime capability state changed after the preview, so nothing was forced.");
+                this.invalidateObservedState();
+                this.record(message, "attention");
+                return {
+                  ok: false,
+                  title: "Optimizer update was not applied",
+                  messages: [message],
+                  appliedPlans: 0
+                };
+              }
+              appliedCount = result6.data.execution?.results.filter((row2) => row2.status === "applied").length ?? 0;
+            }
+            let inventory;
+            try {
+              inventory = await this.call(["doctor"]);
+            } catch {
+              this.invalidateObservedState();
+              const message = "The installer returned, but Token Harness could not re-read the active optimizer runtimes. The update is not being reported as successful. Refresh and inspect the installed versions.";
+              this.record(message, "attention");
+              return {
+                ok: false,
+                title: "Update result needs checking",
+                messages: [message],
+                appliedPlans: appliedCount
+              };
+            }
+            const missing = approvedUpdates.filter((target) => {
+              const detection = inventory.data?.providers.find((candidate) => candidate.providerId === target.provider);
+              return !sameGuideVersion(detection?.version ?? null, target.version);
+            });
+            if (inventory.data === null || missing.length > 0) {
+              const message = missing.length > 0 ? "The approved update target was not observed on the active PATH after installation: " + missing.map((target) => `${name(target.provider)} ${target.version}`).join(", ") + ". This is not being reported as a successful update." : "The active optimizer versions could not be verified after installation. This is not being reported as a successful update.";
+              this.invalidateObservedState();
+              this.record(message, "attention");
+              return {
+                ok: false,
+                title: "Update was not verified",
+                messages: [
+                  message,
+                  "Refresh after correcting PATH or the package installation; no automatic retry was made."
+                ],
+                appliedPlans: appliedCount
+              };
+            }
             this.lastApplied = null;
             this.invalidateObservedState();
-            const messages2 = applied.length > 0 ? [
-              "The reviewed optimizer update completed successfully.",
-              "Token Harness re-ran the update transaction safety checks before changing software.",
-              "Choose Refresh to read the installed versions again. Reopen a coding agent if the updated optimizer requires it."
-            ] : [
-              "No optimizer needed an update by the time the approved action ran.",
-              "Nothing was forced. Choose Refresh to read the current versions."
+            const versions = approvedUpdates.map((target) => `${name(target.provider)} ${target.version}`).join(", ");
+            const messages2 = [
+              appliedCount > 0 ? `Installed and verified the approved optimizer version${approvedUpdates.length === 1 ? "" : "s"}: ${versions}.` : `The approved optimizer version${approvedUpdates.length === 1 ? " was" : "s were"} already active when the final check ran: ${versions}.`,
+              "The active runtime was re-read after the operation; success is shown only because it matches the approved target.",
+              "Reopen a coding agent if the updated optimizer requires it."
             ];
-            this.record(applied.length > 0 ? "Reviewed optimizer update installed." : "Optimizer update no longer needed.", "success");
+            this.record(appliedCount > 0 ? "Optimizer update installed and verified." : "Approved optimizer version already active and verified.", "success");
             return {
               ok: true,
-              title: applied.length > 0 ? "Optimizer updated" : "Already up to date",
+              title: appliedCount > 0 ? "Optimizer updated" : "Approved version already active",
               messages: messages2,
-              appliedPlans: applied.length
+              appliedPlans: appliedCount
             };
           }
           if (approval.operation === "candidate-apply" || approval.operation === "candidate-uninstall") {
@@ -33078,7 +33773,7 @@ var init_guided = __esm({
             this.record(`${name(provider)} managed integration removed.`, "success");
             return { ok: true, title: "Integration removed", messages: messages2, appliedPlans: 1 };
           }
-          this.record(approval.operation === "rollback" ? "Restoring the reviewed configuration backup." : "Backing up and applying exactly the changes you approved.", "working");
+          this.record(approval.operation === "rollback" ? "Restoring the approved configuration backup." : "Backing up and applying exactly the changes you approved.", "working");
           const messages = [];
           let appliedPlans = 0;
           const steps = approval.operation === "rollback" && approval.transactionId !== null ? [
@@ -33122,7 +33817,7 @@ var init_guided = __esm({
             this.lastApplied = approval.operation === "rollback" ? null : step.plan === null ? null : { kind: "plan", plan: step.plan, network: approval.network };
           }
           this.invalidateObservedState();
-          messages.push(approval.operation === "rollback" ? "The reviewed backup was restored. Reopen the affected coding agent." : "The approved configuration was saved and checked. Reopen the affected coding agent to load it.");
+          messages.push(approval.operation === "rollback" ? "The approved backup was restored. Reopen the affected coding agent." : "The approved configuration was saved and checked. Reopen the affected coding agent to load it.");
           messages.push("Keep using the agent normally. The dashboard reads available measurements automatically; it does not need to stay open for the configured integration to operate.");
           this.record(`${approval.description} applied and verified against its configuration checks.`, "success");
           return {
@@ -33176,18 +33871,21 @@ var init_guided = __esm({
           }
           this.updates = { fingerprint, report: updateResult.data };
           const available = updateResult.data.providers.filter((row2) => row2.verdict === "upgradable");
+          const updateTargets = available.flatMap((row2) => row2.available === null ? [] : [{ provider: row2.providerId, version: row2.available }]);
           const blocked = updateResult.data.providers.filter((row2) => row2.verdict === "blocked-unreviewed");
           const messages = [];
           if (available.length > 0) {
-            messages.push(...available.map((row2) => `${name(row2.providerId)}: ${row2.installed ?? "installed version"} \u2192 ${row2.available ?? "new version"} is reviewed and ready to install.`));
+            messages.push(...available.map((row2) => `${name(row2.providerId)}: ${row2.installed ?? "installed version"} \u2192 ${row2.available ?? "new version"} is available and ready to install; Token Harness will verify the active runtime after installation.`));
           }
           if (blocked.length > 0) {
-            messages.push(...blocked.map((row2) => `${name(row2.providerId)}: ${row2.available ?? "a newer version"} exists, but Token Harness is keeping ${row2.installed ?? "the installed version"} because that newer combination is not reviewed yet.`));
+            messages.push(...blocked.map((row2) => `${name(row2.providerId)}: ${row2.available ?? "a newer version"} exists, but Token Harness is keeping ${row2.installed ?? "the installed version"} because the target does not meet the provider update prerequisites.`));
           }
           if (available.length === 0 && blocked.length === 0)
-            messages.push("Your managed optimizers are up to date on their reviewed channels.");
+            messages.push("Your managed optimizers are up to date on their configured channels.");
           let ticket = null;
-          if (available.length > 0) {
+          if (available.length > 0 && updateTargets.length !== available.length) {
+            messages.push("An update channel reported an upgradable optimizer without a concrete target version. No install approval was created.");
+          } else if (updateTargets.length > 0) {
             ticket = this.random();
             const expires = this.now() + 10 * 6e4;
             this.approval = {
@@ -33198,7 +33896,8 @@ var init_guided = __esm({
               provider: null,
               description: "Optimizer updates",
               operation: "update",
-              network: updateResult.data.network.length > 0
+              network: updateResult.data.network.length > 0,
+              updateTargets
             };
             messages.push("Review the versions above, then choose Install updates. Token Harness will re-check the update channels and transaction safety rules before changing software.");
           } else {
@@ -33207,10 +33906,10 @@ var init_guided = __esm({
           const stack = this.stackSnapshot();
           if (this.cached !== null)
             this.cached.value = { ...this.cached.value, stack };
-          this.record(available.length > 0 ? "Reviewed optimizer update available. Waiting for your approval." : "Provider update check completed. No reviewed update is pending.", "success");
+          this.record(ticket !== null ? "Optimizer update available. Waiting for your approval." : available.length > 0 ? "Provider update check could not produce an exact install target." : "Provider update check completed. No update is pending.", "success");
           return {
             ok: true,
-            title: available.length > 0 ? "Updates available" : "Optimizers up to date",
+            title: ticket !== null ? "Updates available" : available.length > 0 ? "Update check needs attention" : "Optimizers up to date",
             messages,
             appliedPlans: 0,
             stack,
@@ -34979,7 +35678,7 @@ var init_guided_capabilities_client = __esm({
     const activeRun = runId;
     working = true;
     $('modal-actions').replaceChildren(closeButton('Applying…', true));
-    $('modal-content').append(progress('Applying the reviewed change', 'Only the approved transaction is being applied. Keep this window open until it finishes.'));
+    $('modal-content').append(progress('Applying the approved change', 'Only the approved transaction is being applied. Keep this window open until it finishes.'));
     try {
       const result = await request('/api/apply', { ticket });
       if (activeRun !== runId) return;
@@ -35077,7 +35776,7 @@ var init_guided_capabilities_client = __esm({
       return preview(
         { action: 'skill', harness: action.harness },
         'Review in-session guidance for ' + (action.harness === 'claude' ? 'Claude Code' : 'Codex'),
-        'Enable reviewed guidance',
+        'Enable managed guidance',
         'Guidance enabled',
       );
     if (action.kind === 'refresh') return $('refresh')?.click();
@@ -35166,7 +35865,7 @@ var init_guided_capabilities_client = __esm({
         actionButton('Review removal', () => preview(
           { action: 'remove', provider: component.providerId },
           'Review removal for ' + name,
-          'Remove reviewed integration',
+          'Remove managed integration',
           'Integration removed',
         ), 'secondary'),
       );
@@ -35267,24 +35966,24 @@ var init_guided_product_client = __esm({
     },
     harnesstrim: {
       name: 'HarnessTrim',
-      role: 'Adds reviewed instructions that help coding agents keep tool output and context lean.',
+      role: 'Adds version-aware instructions that help coding agents keep tool output and context lean.',
       managed: true,
     },
     mcptoon: {
       name: 'mcptoon',
-      role: 'Provides the reviewed compact MCP discovery integration on exact admitted versions.',
+      role: 'Provides compact MCP discovery integration and verifies the resulting setup.',
       managed: true,
       optional: true,
     },
     gitnexus: {
       name: 'GitNexus',
-      role: 'Registers an already-installed reviewed GitNexus CLI as a narrow Claude MCP integration.',
+      role: 'Registers an already-installed GitNexus CLI as a narrow Claude MCP integration and verifies the result.',
       managed: true,
       optional: true,
     },
     headroom: {
       name: 'Headroom',
-      role: 'Provides local MCP compression and retrieval through the reviewed Headroom server.',
+      role: 'Provides local MCP compression and retrieval through the installed Headroom server.',
       managed: true,
       optional: true,
     },
@@ -35342,7 +36041,7 @@ var init_guided_product_client = __esm({
       element.disabled = value;
     });
     $('live-status').textContent = value
-      ? (applying ? 'Applying only the reviewed change…' : 'Reading current state…')
+      ? (applying ? 'Applying only the approved change…' : 'Reading current state…')
       : 'Nothing changes without your approval';
   }
 
@@ -35496,7 +36195,7 @@ var init_guided_product_client = __esm({
     if (unavailable.length)
       return {
         state: 'limited',
-        label: 'Reviewed setup complete',
+        label: 'Setup complete',
         cls: 'good',
         actionable,
         unavailable,
@@ -35589,7 +36288,7 @@ var init_guided_product_client = __esm({
         label: 'Needs attention',
         cls: 'warn',
         title: 'One configured optimizer needs attention',
-        detail: 'Use Re-check health below to see whether the configured integration still matches its reviewed state.',
+        detail: 'Use Re-check health below to see whether the configured integration still matches the provider and agent state currently installed.',
         action: 'verify',
       };
     if (incomplete.length)
@@ -35599,7 +36298,7 @@ var init_guided_product_client = __esm({
         title: incomplete.length === 1
           ? 'Finish setup for ' + incomplete[0].name
           : 'Finish the available recommended setup for your coding agents',
-        detail: 'Every Finish setup action below has at least one reviewed provider change available for that exact agent, version and platform.',
+        detail: 'Every Finish setup action below has a concrete change available from the installed provider. Newer version combinations are attempted transactionally and checked again after apply.',
         action: 'configure',
       };
     const unavailable = baselineUnavailableAgents();
@@ -35607,8 +36306,8 @@ var init_guided_product_client = __esm({
       return {
         label: 'No automatic setup',
         cls: '',
-        title: 'No reviewed automatic setup is currently available',
-        detail: 'Token Harness will not show a setup button that cannot complete. The agent cards below explain which provider/version combination is not currently managed.',
+        title: 'No automatic setup surface is currently exposed',
+        detail: 'The installed provider does not currently expose the setup surface Token Harness needs. This is a capability limitation, not a missing review row.',
         action: 'none',
       };
     if (!(current?.savings?.rows || []).length)
@@ -35667,16 +36366,21 @@ var init_guided_product_client = __esm({
   function componentState(id, component) {
     if (!component || component.detectedState === 'absent') return { label: 'Not installed', cls: '' };
     if (component.health === 'attention') return { label: 'Needs attention', cls: 'warn' };
-    if (component.configured)
+    const targets = activeAgents().map(agent => setupTarget(agent.id, id)).filter(Boolean);
+    const connectedHere = targets.some(target => target.state === 'connected');
+    const actionableHere = targets.some(target => target.state === 'actionable');
+    if (component.installed && actionableHere && connectedHere)
+      return { label: 'Partially connected · setup available', cls: 'warn' };
+    if (component.installed && actionableHere)
+      return { label: 'Installed · setup available', cls: 'warn' };
+    if (connectedHere)
       return {
         label: component.verification === 'verified' ? 'Connected · verified' : 'Connected',
         cls: 'good',
       };
-    const targets = activeAgents().map(agent => setupTarget(agent.id, id)).filter(Boolean);
-    if (component.installed && targets.some(target => target.state === 'actionable'))
-      return { label: 'Installed · setup available', cls: 'warn' };
     if (component.installed && targets.some(target => target.state === 'unavailable'))
       return { label: 'Installed · no automatic setup', cls: '' };
+    if (component.configured) return { label: 'Connected elsewhere', cls: '' };
     if (component.installed) return { label: 'Installed', cls: '' };
     return { label: 'Not installed', cls: '' };
   }
@@ -35703,22 +36407,32 @@ var init_guided_product_client = __esm({
     const actionableFor = providerTargets
       .filter(item => item.target.state === 'actionable')
       .map(item => item.agent.name);
-    const unavailableFor = providerTargets.filter(item => item.target.state === 'unavailable');
-    const configuredFor = component?.configuredHarnesses?.length
-      ? component.configuredHarnesses.map(agentName).join(', ')
-      : actionableFor.length
-        ? 'Setup available for ' + actionableFor.join(', ')
-        : unavailableFor.length
-          ? 'No reviewed automatic connection is available'
-          : 'Not applicable to the detected coding agents';
-    facts.append(node('span', 'Connection'), node('strong', configuredFor));
+    const unavailableFor = providerTargets
+      .filter(item => item.target.state === 'unavailable')
+      .map(item => item.agent.name);
+    const notApplicableFor = providerTargets
+      .filter(item => item.target.state === 'not-applicable')
+      .map(item => item.agent.name);
+    const connectedFor = component?.configuredHarnesses?.length
+      ? component.configuredHarnesses.map(agentName)
+      : [];
+    if (connectedFor.length)
+      facts.append(node('span', 'Connected to'), node('strong', connectedFor.join(', ')));
+    if (actionableFor.length)
+      facts.append(node('span', 'Setup available'), node('strong', actionableFor.join(', ')));
+    if (unavailableFor.length)
+      facts.append(node('span', 'Automatic setup unavailable'), node('strong', unavailableFor.join(', ')));
+    if (notApplicableFor.length)
+      facts.append(node('span', 'Not applicable'), node('strong', notApplicableFor.join(', ')));
+    if (!connectedFor.length && !actionableFor.length && !unavailableFor.length && !notApplicableFor.length)
+      facts.append(node('span', 'Connection'), node('strong', 'No detected coding agent target'));
     if (component?.update === 'available')
       facts.append(
         node('span', 'Update'),
         node('strong', 'v' + (component.updateAvailableVersion || 'new version') + ' available'),
       );
     else if (component?.update === 'blocked')
-      facts.append(node('span', 'Update'), node('strong', 'Newer version not reviewed yet'));
+      facts.append(node('span', 'Update'), node('strong', 'Newer package requires a provider-specific update path'));
     card.append(facts);
 
     if (
@@ -35730,7 +36444,8 @@ var init_guided_product_client = __esm({
       card.append(
         messageBox(
           'Why there is no Connect button',
-          unavailableFor[0].target.reason,
+          providerTargets.find(item => item.target.state === 'unavailable')?.target.reason ||
+            'The installed provider does not expose an automatic setup surface for this coding agent.',
         ),
       );
 
@@ -35795,14 +36510,14 @@ var init_guided_product_client = __esm({
       head.append(title, pill(baseline.label, baseline.cls));
       const detail =
         baseline.state === 'incomplete'
-          ? 'A reviewed automatic setup is available for ' +
+          ? 'An automatic setup is available for ' +
             baseline.actionable.map(target => target.provider).join(' + ') +
             '. Finish setup to review and apply it.'
           : baseline.state === 'unavailable'
-            ? 'No reviewed automatic baseline change is available for this exact agent, provider versions and platform. Token Harness will not offer a no-op setup button.'
+            ? 'The installed baseline providers do not currently expose an automatic setup surface for this agent. Token Harness will not offer a no-op button.'
             : baseline.state === 'limited'
-              ? 'All currently reviewed automatic baseline actions are complete. Other baseline combinations are not automatically changed on this version/platform.'
-              : 'All reviewed automatic baseline connections available for this coding agent are configured.';
+              ? 'All automatic baseline actions exposed by the installed providers are complete.'
+              : 'All automatic baseline connections exposed for this coding agent are configured.';
       card.append(head, node('p', detail));
       if (agent.providers?.length)
         card.append(
@@ -35843,7 +36558,7 @@ var init_guided_product_client = __esm({
         'Safe preview first',
         provider
           ? 'Token Harness will inspect only ' + provider.name + ' for ' + agent.name + '. If setup is supported, the exact change appears before you confirm it.'
-          : 'Token Harness will prepare only the reviewed RTK/HarnessTrim changes that are actually available for ' + agent.name + ' on this version and platform. The exact files and changes appear before you confirm them.',
+          : 'Token Harness will prepare the RTK/HarnessTrim changes exposed by the installed providers for ' + agent.name + '. Newer combinations use the same transactional path and are checked again after apply. The exact files and changes appear before you confirm them.',
       ),
       messageBox('Nothing changes yet', 'This first step only prepares the safe plan. You decide whether to apply it after seeing the concrete changes.'),
       progress('Checking ' + agent.name, 'Reading installed optimizer versions and current integration state.'),
@@ -35880,7 +36595,7 @@ var init_guided_product_client = __esm({
             provider ? 'This optimizer only' : 'Recommended setup',
             provider
               ? 'This approval changes only ' + provider.name + ' for ' + agent.name + '. Other optimizers are left unchanged.'
-              : 'This review includes only the currently actionable RTK/HarnessTrim changes for ' + agent.name + '. Unsupported or already-complete baseline providers are left out. Optional optimizers stay separate.',
+              : 'This review includes only the currently actionable RTK/HarnessTrim changes for ' + agent.name + '. Providers that do not expose the required setup surface, and already-complete providers, are left out. Optional optimizers stay separate.',
           ),
         );
         if (!data.changes.length) {
@@ -35888,7 +36603,7 @@ var init_guided_product_client = __esm({
             messageBox(
               'No setup change available',
               (data.notices || []).join(' ') ||
-                'No reviewed automatic change is available now. The dashboard is refreshing so an obsolete setup action is not left visible.',
+                'No automatic change is available from the provider’s current capability surface. The dashboard is refreshing so an obsolete setup action is not left visible.',
             ),
           );
         } else {
@@ -35899,7 +36614,7 @@ var init_guided_product_client = __esm({
           }
           for (const notice of data.notices || []) $('modal-content').append(node('p', notice, 'notice-row'));
         }
-        $('modal-content').append(messageBox('Safety', 'Apply uses the existing transactional engine with backups, compatibility checks, ownership checks and rollback. Unsupported versions are not forced.', 'safe'));
+        $('modal-content').append(messageBox('Safety', 'Apply uses the transactional engine with backups, ownership checks and rollback. A newer version tuple is allowed when the installed provider exposes the required capability, then the resulting state is checked again after apply.', 'safe'));
         $('modal-actions').replaceChildren(modalClose(data.ticket ? 'Cancel' : 'Done'));
         if (data.ticket)
           $('modal-actions').append(
@@ -35933,7 +36648,7 @@ var init_guided_product_client = __esm({
     const run = modalRun;
     setBusy(true, true);
     $('modal-actions').replaceChildren(modalClose('Applying…', true));
-    $('modal-content').append(progress('Applying the reviewed change', 'Keep this window open until the transaction finishes.'));
+    $('modal-content').append(progress('Applying the approved change', 'Keep this window open until the transaction finishes.'));
     try {
       await ensureSession();
       const result = await request('/api/apply', { ticket });
@@ -36246,7 +36961,7 @@ var init_guided_product_client = __esm({
         isVerify ? 'Troubleshooting check' : 'Update preview',
         isVerify
           ? 'Re-checks the configured optimizer integrations without repairing or changing them. Normal setup already performs its own safety checks.'
-          : 'Checks reviewed update channels first. If an installable update exists, you can approve it from this window.',
+          : 'Checks provider update channels first. If an installable update exists, you can approve it from this window; the active executable is re-checked after installation before success is reported.',
       ),
       progress(
         isVerify ? 'Checking configured optimizers' : 'Checking update channels',
@@ -36357,7 +37072,7 @@ var init_guided_product_client = __esm({
         'p',
         available.length
           ? available.map(component => (TOOL_INFO[component.providerId]?.name || component.providerId) + ' has an update ready.').join(' ')
-          : 'Check installed optimizer versions. If a reviewed update is available, you can install it from the same dialog.',
+          : 'Check installed optimizer versions. If an update is available, you can install it from the same dialog; Token Harness verifies the active runtime after installation.',
         'caption',
       ),
     );