token-harness 0.1.1 → 0.1.2

package/token-harness.mjs

@@ -111,6 +111,113 @@ function classifyVersion(observed, range) {
   return compareVersions(version2, maximum) > 0 ? "unknown-newer" : "in-range";
 }
 
+// packages/core/dist/src/domain/compatibility-rows.js
+var COMPATIBILITY_ROWS = [
+  {
+    harness: "claude",
+    harnessVersion: { minimum: "2.1.220", maximum: "2.1.220" },
+    provider: "rtk",
+    providerVersion: "0.44.0",
+    platform: { os: "windows", wsl: false, supported: true, limitation: null },
+    configSchema: "claude-settings-json-hooks",
+    fixture: "tests/fixtures/rows/rtk-claude-windows",
+    verificationTier: "canary"
+  },
+  {
+    harness: "claude",
+    harnessVersion: { minimum: "2.1.220", maximum: "2.1.220" },
+    provider: "harnesstrim",
+    providerVersion: "0.1.0",
+    platform: { os: "windows", wsl: false, supported: true, limitation: null },
+    // The install writes skill files, not a document this build parses, so the schema it depends on
+    // is the skills directory layout rather than `settings.json`.
+    configSchema: "claude-skills-directory",
+    fixture: "tests/fixtures/rows/harnesstrim-claude-windows",
+    verificationTier: "config-only"
+  }
+];
+function classifyRowHarnessVersion(rows, observed) {
+  if (rows.length === 0)
+    return null;
+  const parsed = parseSemanticVersion(observed);
+  if (parsed === null)
+    return null;
+  let lowestMinimum = null;
+  let highestMaximum = null;
+  for (const row2 of rows) {
+    const minimum = parseSemanticVersion(row2.harnessVersion.minimum);
+    const maximum = parseSemanticVersion(row2.harnessVersion.maximum);
+    if (minimum === null || maximum === null)
+      continue;
+    if (compareVersions(parsed, minimum) >= 0 && compareVersions(parsed, maximum) <= 0)
+      return "in-row";
+    if (lowestMinimum === null || compareVersions(minimum, lowestMinimum) < 0)
+      lowestMinimum = minimum;
+    if (highestMaximum === null || compareVersions(maximum, highestMaximum) > 0)
+      highestMaximum = maximum;
+  }
+  if (lowestMinimum === null || highestMaximum === null)
+    return null;
+  if (compareVersions(parsed, lowestMinimum) < 0)
+    return "unknown-older";
+  if (compareVersions(parsed, highestMaximum) > 0)
+    return "unknown-newer";
+  return "below-range";
+}
+function rowsFor(rows, combination) {
+  return rows.filter((row2) => row2.provider === combination.provider && row2.harness === combination.harness && row2.platform.os === combination.os && row2.platform.wsl === combination.wsl && row2.platform.supported);
+}
+function admitManagedMutation(rows, combination) {
+  const keyed = rowsFor(rows, combination);
+  if (combination.providerVersion === null)
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: "the exact provider version a row would record could not be established"
+    };
+  if (combination.harnessVersion === null)
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: "the exact harness version a row would cover could not be established"
+    };
+  if (keyed.length === 0)
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: `a reviewed config schema and fixture for ${combination.provider} on ${combination.harness} at ${combination.providerVersion} on ${combination.os}`
+    };
+  const versioned = keyed.filter((row3) => row3.providerVersion === combination.providerVersion);
+  if (versioned.length === 0) {
+    const fixture = keyed[0]?.fixture ?? "a provider fixture";
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: `a provider fixture covering ${combination.provider} at ${combination.providerVersion} (the nearest row's fixture is ${JSON.stringify(fixture)})`
+    };
+  }
+  const parsedHarness = parseSemanticVersion(combination.harnessVersion);
+  const row2 = versioned.find((candidate) => {
+    const minimum = parseSemanticVersion(candidate.harnessVersion.minimum);
+    const maximum = parseSemanticVersion(candidate.harnessVersion.maximum);
+    return minimum !== null && maximum !== null && parsedHarness !== null && compareVersions(parsedHarness, minimum) >= 0 && compareVersions(parsedHarness, maximum) <= 0;
+  });
+  if (row2 !== void 0)
+    return { state: "admitted", row: row2 };
+  const verdict = parsedHarness === null ? null : classifyRowHarnessVersion(versioned, combination.harnessVersion);
+  if (verdict === null || verdict === "in-row")
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: `a reviewed config schema and fixture for ${combination.provider} on ${combination.harness}`
+    };
+  return {
+    state: "refused",
+    verdict,
+    missing: verdict === "unknown-newer" ? `a harness schema for ${combination.harness} newer than every row's maximum (the newest row names schema ${JSON.stringify(versioned[0]?.configSchema ?? "none")})` : verdict === "unknown-older" ? `a harness schema for ${combination.harness} older than every row's minimum (the oldest row names schema ${JSON.stringify(versioned[0]?.configSchema ?? "none")})` : `a harness schema covering ${combination.harness} at ${combination.harnessVersion}, between the rows that name schemas ${JSON.stringify(keyed.map((entry) => entry.configSchema))}`
+  };
+}
+
 // packages/core/dist/src/domain/compatibility.js
 function coversHarness(rule, harness) {
   return rule.harnesses === "*" || rule.harnesses.includes(harness);
@@ -207,6 +314,7 @@ function harnessId(value) {
   }
   return value;
 }
+var UNATTRIBUTED_PROJECT_ID = "p_unattributed";
 
 // packages/core/dist/src/domain/manifest.js
 var MANIFEST_SCHEMA_VERSION = 1;
@@ -588,12 +696,13 @@ function resolveOwnership(input) {
             continue;
           }
           if (!provider.assignable) {
+            const observed = input.observedVersions[provider.id] ?? null;
             exclusions.push({
               scope,
               excluded: provider.id,
               retained: null,
               reason: [
-                `${provider.id} implements ${capability} but no installer state produces it in isolation`,
+                observed === null ? `${provider.id} implements ${capability} but no installer state this build could observe produces it in isolation` : `${provider.id} ${observed} implements ${capability} but no installer state at that version produces it in isolation`,
                 "RFC 0003: a capability the provider has but cannot be asked for is not an assignable capability",
                 "It is still detected, adopted, reconciled against the owner, and measured"
               ]
@@ -634,6 +743,7 @@ function resolveOwnership(input) {
       }
     }
   }
+  narrowChannelOverlaps({ ownership, exclusions, conflicts, input });
   const ownerByScope = new Map(ownership.map((entry) => [formatCapabilityScope(entry.scope), entry.owner]));
   for (const exclusion of exclusions) {
     if (exclusion.retained !== null)
@@ -644,6 +754,66 @@ function resolveOwnership(input) {
   }
   return { ownership, exclusions, conflicts, pipelineId: derivePipelineId(ownership) };
 }
+function narrowChannelOverlaps(context) {
+  const { ownership, exclusions, conflicts, input } = context;
+  const channels = /* @__PURE__ */ new Map();
+  for (const entry of ownership) {
+    if (entry.mode !== "exclusive")
+      continue;
+    const key = `${entry.scope.harness}/${entry.scope.toolFamily}/${entry.scope.capability}`;
+    const group = channels.get(key) ?? [];
+    group.push(entry);
+    channels.set(key, group);
+  }
+  const dropped = /* @__PURE__ */ new Set();
+  for (const group of channels.values()) {
+    const owners = [...new Set(group.map((entry) => entry.owner))];
+    if (owners.length < 2)
+      continue;
+    const first = group[0];
+    if (first === void 0)
+      continue;
+    const { harness, toolFamily, capability } = first.scope;
+    const rule = findCompatibilityRule(input.rules, { providers: owners, harness, capability });
+    if (rule === null || rule.outcome !== "narrowed" || rule.retains === void 0) {
+      conflicts.push({
+        code: "exclusive-scope-contested",
+        scope: `${harness}/${toolFamily}/${capability}`,
+        claimants: [...owners].sort(),
+        detail: [
+          `${owners.join(" and ")} each own ${capability} on ${harness}/${toolFamily}, at different interception points`,
+          "The interception points differ but the payload does not, so the reduction would run twice",
+          rule === null ? "No rule names this pair on this channel, and an unreviewed overlap is not permission" : `Rule ${rule.id} does not say which provider keeps the channel`
+        ],
+        remediation: `Choose one owner for ${harness}/${toolFamily}/${capability} with \`profile: custom\``
+      });
+      for (const entry of group)
+        dropped.add(entry);
+      continue;
+    }
+    const retains = rule.retains;
+    for (const entry of group) {
+      if (entry.owner === retains)
+        continue;
+      dropped.add(entry);
+      exclusions.push({
+        scope: entry.scope,
+        excluded: entry.owner,
+        retained: retains,
+        reason: [
+          `rule ${rule.id} keeps ${capability} on ${harness}/${toolFamily} with ${retains}, at every interception point`,
+          `${entry.owner} is narrowed to the install its own flags produce rather than excluded whole`,
+          rule.rationale
+        ]
+      });
+    }
+  }
+  if (dropped.size > 0) {
+    const kept = ownership.filter((entry) => !dropped.has(entry));
+    ownership.length = 0;
+    ownership.push(...kept);
+  }
+}
 function resolveContested(context) {
   const { scope, claims, capability, input, ownership, exclusions, conflicts } = context;
   const claimants = claims.map((claim) => claim.provider);
@@ -719,6 +889,41 @@ function resolveContested(context) {
     }
     return;
   }
+  if (rule.outcome === "narrowed") {
+    const retains = rule.retains;
+    if (retains === void 0) {
+      conflicts.push({
+        code: "compatibility-rule-malformed",
+        scope: formatCapabilityScope(scope),
+        claimants,
+        detail: [
+          `Rule ${rule.id} narrows a pair without naming which provider keeps the channel`,
+          "Choosing one here would make the resolver decide what the rule exists to record"
+        ],
+        remediation: `Fix rule ${rule.id} so it names the provider that retains the capability`
+      });
+      return;
+    }
+    for (const claimant of claimants) {
+      if (claimant === retains)
+        continue;
+      exclusions.push({
+        scope,
+        excluded: claimant,
+        retained: retains,
+        reason: [
+          `rule ${rule.id} keeps ${capability} on ${scope.harness} with ${retains}`,
+          `${claimant} is narrowed to the install its own flags produce rather than excluded whole`,
+          rule.rationale
+        ]
+      });
+    }
+    const retainedClaim = claims.find((claim) => claim.provider === retains);
+    if (retainedClaim !== void 0) {
+      ownership.push({ scope, owner: retains, mode: retainedClaim.mode, order: 0 });
+    }
+    return;
+  }
   const winner = rule.providers.find((provider) => claimants.includes(provider)) ?? claimants[0];
   for (const claimant of claimants) {
     if (claimant === winner)
@@ -749,9 +954,10 @@ var RTK_HARNESSTRIM_SHELL_OVERLAP = {
   // for different reasons. Listing them individually would imply a fourth harness is exempt.
   harnesses: "*",
   capabilities: ["shell.output.reduce"],
-  outcome: "conflict",
-  testedVersions: { rtk: "0.42.0", harnesstrim: "0.0.5" },
-  rationale: "HarnessTrim 0.0.5 reduces the same command output RTK already reduced, and no configuration narrows it: its Claude and Codex adapters match Bash only, and its OpenCode plugin reduces every tool result. Reducing an already reduced payload loses signal and counts the saving twice.",
+  outcome: "narrowed",
+  retains: RTK,
+  testedVersions: { rtk: "0.44.0", harnesstrim: "0.1.0" },
+  rationale: "RTK keeps shell output reduction: it rewrites the command, so the output arriving at any later point is already reduced, and reducing it again loses signal and counts the saving twice. HarnessTrim 0.1.0 no longer has to be excluded whole for that \u2014 `--no-hook` and `--no-instructions` produce a Claude install that adds skills and reduces nothing, and `--tools` confines its OpenCode reduction to a chosen tool family. So it is narrowed to the form that leaves this channel alone, rather than refused. At 0.0.5 no flag produced any of those states, which is why this rule read `conflict` and said no configuration narrows it.",
   fixtures: ["docs/rfcs/0003-capabilities-and-conflicts.md#the-table-is-an-intent"]
 };
 var COMPATIBILITY_RULES = [RTK_HARNESSTRIM_SHELL_OVERLAP];
@@ -1270,6 +1476,201 @@ async function queryAvailableVersion(input) {
   }
   return { status: "found", version: version2, destination, diagnostics };
 }
+var INVENTORY_COMMANDS = {
+  /**
+   * `winget list --id <id> --exact` prints the same dashes-anchored table as `show --versions`,
+   * with the installed version as the last token of the row. The header is localized, which is
+   * why the parse is anchored on the separator and the row tail rather than on a column title.
+   *
+   * A missing package makes winget exit non-zero with a localized "no package found" message,
+   * which this build cannot tell from any other failure — so that case is `failed` at the caller,
+   * never `absent`.
+   */
+  winget: {
+    executable: "winget",
+    args: (packageName) => ["list", "--id", packageName, "--exact"],
+    parse: (stdout, _packageName) => {
+      const lines = stdout.split(/\r?\n/);
+      const separator = lines.findIndex((line) => /^-{3,}\s*$/.test(line.trim()));
+      if (separator < 0)
+        return { status: "unknown", version: null };
+      for (const line of lines.slice(separator + 1)) {
+        const row2 = line.trim();
+        if (row2 === "")
+          continue;
+        const candidate = row2.split(/\s+/).at(-1) ?? "";
+        if (parseSemanticVersion(candidate) === null)
+          return { status: "unknown", version: null };
+        return { status: "captured", version: candidate };
+      }
+      return { status: "unknown", version: null };
+    },
+    verified: false
+  },
+  /**
+   * `cargo install --list` prints one `crate v0.1.0:` line per installed crate, so absence is a
+   * positive answer: the crate simply does not appear. This is the one inventory among the six
+   * that can confirm absence.
+   */
+  cargo: {
+    executable: "cargo",
+    args: () => ["install", "--list"],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^\\s*${packageName}\\s+v(\\S+)\\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 };
+    },
+    verified: false
+  },
+  npm: {
+    executable: "npm",
+    args: (packageName) => ["ls", "-g", packageName, "--depth=0"],
+    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) {
+        return { status: "unknown", version: null };
+      }
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  },
+  homebrew: {
+    executable: "brew",
+    args: (packageName) => ["list", "--versions", packageName],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^${packageName}\\s+(.+)$`);
+      const match = pattern.exec(stdout.trim());
+      const candidate = match?.[1]?.trim().split(/\s+/).at(-1) ?? null;
+      if (candidate === null || parseSemanticVersion(candidate) === null) {
+        return { status: "unknown", version: null };
+      }
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  },
+  uv: {
+    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 };
+    },
+    verified: false
+  },
+  pipx: {
+    executable: "pipx",
+    args: () => ["list"],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^\\s*${packageName}\\s+(\\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 };
+    },
+    verified: false
+  }
+};
+function channelCanReportInventory(channelId) {
+  return Object.hasOwn(INVENTORY_COMMANDS, channelId);
+}
+var DEFAULT_INVENTORY_TIMEOUT_MS = 6e4;
+async function queryPackageInventory(input) {
+  const recipe = INVENTORY_COMMANDS[input.channel];
+  if (recipe === void 0) {
+    return {
+      channel: input.channel,
+      packageName: input.packageName,
+      status: "unsupported",
+      version: null,
+      diagnostics: [
+        diagnostic({
+          severity: "warning",
+          code: "inventory-query-unsupported",
+          message: `This build cannot ask ${input.channel} what it has installed`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  if (input.runner === null) {
+    return {
+      channel: input.channel,
+      packageName: input.packageName,
+      status: "failed",
+      version: null,
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "no-process-runner",
+          message: "No process runner is available, so no inventory can be captured",
+          remediation: null
+        })
+      ]
+    };
+  }
+  const diagnostics = [];
+  if (!recipe.verified) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "inventory-query-unverified",
+      message: `The ${input.channel} inventory query follows that tool's documented output but has not been observed working`,
+      remediation: "Confirm the rollback receipt after any failure"
+    }));
+  }
+  const outcome2 = await input.runner.run({
+    executable: recipe.executable,
+    args: recipe.args(input.packageName),
+    cwd: input.cwd,
+    timeoutMs: input.timeoutMs ?? DEFAULT_INVENTORY_TIMEOUT_MS
+  });
+  if (outcome2.failure !== null || outcome2.exitCode !== 0) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "inventory-query-failed",
+      message: outcome2.failure === null ? `${outcome2.displayCommand} exited with ${String(outcome2.exitCode)}` : `${recipe.executable} could not be run: ${outcome2.failure.reason}`,
+      remediation: null
+    }));
+    return {
+      channel: input.channel,
+      packageName: input.packageName,
+      status: "failed",
+      version: null,
+      diagnostics
+    };
+  }
+  const reading = recipe.parse(outcome2.stdout, input.packageName);
+  if (reading.status === "unknown") {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "inventory-query-unreadable",
+      message: `${recipe.executable} answered, but its output did not name an installed version in the form this build reads`,
+      remediation: null
+    }));
+  }
+  return {
+    channel: input.channel,
+    packageName: input.packageName,
+    status: reading.status,
+    version: reading.version,
+    diagnostics
+  };
+}
 var DEFAULT_INSTALL_TIMEOUT_MS = 6e5;
 async function runPackageManagerInstall(input) {
   const { action } = input;
@@ -1349,14 +1750,119 @@ async function runPackageManagerInstall(input) {
     }));
     return { status: "failed", diagnostics };
   }
-  diagnostics.push(diagnostic({
-    severity: "info",
-    code: "install-not-reversible",
-    message: `${action.packageName} was installed through ${action.packageManager}; a rollback restores files and will not uninstall it`,
-    remediation: null
-  }));
   return { status: "installed", diagnostics };
 }
+async function restorePackageInventory(input) {
+  const { capture } = input;
+  if (capture.status === "absent") {
+    return {
+      restored: false,
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: "package-inventory-unrestored",
+          message: `${capture.packageName} was not installed before the transaction; restoring that absence would require an uninstall command, so it stays installed`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  if (capture.status !== "captured" || capture.version === null) {
+    return {
+      restored: false,
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: "package-inventory-unrestored",
+          message: `${capture.packageName} was installed without a captured inventory, so it could not be restored`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  if (input.runner === null) {
+    return {
+      restored: false,
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: "package-inventory-unrestored",
+          message: `${capture.packageName} could not be restored: no process runner is available`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  const restoreAction = {
+    kind: "package-manager-install",
+    id: `restore-${capture.packageName}`,
+    riskClass: "delegated",
+    requiresNetwork: true,
+    requiresElevation: false,
+    affectedPaths: [],
+    affectedProcesses: [capture.channel],
+    preconditions: [],
+    postconditions: [],
+    rollbackData: "none",
+    explanation: `Restore ${capture.packageName} to ${capture.version} after a rollback`,
+    packageManager: capture.channel,
+    packageName: capture.packageName,
+    version: capture.version
+  };
+  const result = await runPackageManagerInstall({
+    action: restoreAction,
+    runner: input.runner,
+    cwd: input.cwd,
+    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
+  });
+  if (result.status !== "installed") {
+    return {
+      restored: false,
+      diagnostics: [
+        ...result.diagnostics,
+        diagnostic({
+          severity: "error",
+          code: "package-restore-failed",
+          message: `${capture.packageName} could not be restored to ${capture.version} through ${capture.channel}`,
+          path: null,
+          remediation: `Install ${capture.packageName} at ${capture.version} yourself, then run the command again`
+        })
+      ]
+    };
+  }
+  const verified = await queryPackageInventory({
+    channel: capture.channel,
+    packageName: capture.packageName,
+    runner: input.runner,
+    cwd: input.cwd,
+    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
+  });
+  if (verified.status !== "captured" || verified.version !== capture.version) {
+    return {
+      restored: false,
+      diagnostics: [
+        ...verified.diagnostics,
+        diagnostic({
+          severity: "error",
+          code: "package-restore-failed",
+          message: `${capture.packageName} was reinstalled but the inventory does not report ${capture.version}`,
+          remediation: `Confirm what ${capture.channel} has installed and correct it by hand`
+        })
+      ]
+    };
+  }
+  return {
+    restored: true,
+    diagnostics: [
+      diagnostic({
+        severity: "info",
+        code: "package-inventory-restored",
+        message: `${capture.packageName} was restored to ${capture.version} through ${capture.channel} and the inventory was re-read`,
+        remediation: null
+      })
+    ]
+  };
+}
 
 // packages/core/dist/src/state/json-merge.js
 function isJsonObject(value) {
@@ -1776,7 +2282,8 @@ function outcome(action, status, parts = {}) {
     status,
     snapshots: parts.snapshots ?? [],
     ownership: parts.ownership ?? [],
-    diagnostics: parts.diagnostics ?? []
+    diagnostics: parts.diagnostics ?? [],
+    packageInventory: parts.packageInventory ?? null
   };
 }
 function drift(action, path, message) {
@@ -2055,6 +2562,8 @@ async function scanTree(fs, path, entries = []) {
   return entries;
 }
 function equalTreeEntry(left, right) {
+  if (left === void 0 && right === void 0)
+    return true;
   return left !== void 0 && right !== void 0 && left.kind === right.kind && left.digest === right.digest;
 }
 async function applyDelegatedProviderInstall(action, context) {
@@ -2212,13 +2721,38 @@ async function applyAction(action, context) {
   }
 }
 async function applyPackageManagerInstall(action, context) {
+  const wantsInventory = action.rollbackData === "package-inventory" && !action.requiresElevation;
+  const packageInventory = wantsInventory && context.runner !== void 0 ? await queryPackageInventory({
+    channel: action.packageManager,
+    packageName: action.packageName,
+    runner: context.runner,
+    cwd: context.cwd ?? ""
+  }) : null;
   const result = await runPackageManagerInstall({
     action,
     runner: context.runner ?? null,
     cwd: context.cwd ?? ""
   });
   const status = result.status === "installed" ? "applied" : result.status === "refused" ? "refused" : "failed";
-  return outcome(action, status, { diagnostics: result.diagnostics });
+  const diagnostics = [...result.diagnostics];
+  if (status === "applied") {
+    if (packageInventory?.status === "captured" && packageInventory.version !== null) {
+      diagnostics.push(diagnostic({
+        severity: "info",
+        code: "install-inventory-captured",
+        message: `${action.packageName} was installed through ${action.packageManager}; the prior state (${packageInventory.version}) was captured, so a rollback can restore it`,
+        remediation: null
+      }));
+    } else {
+      diagnostics.push(diagnostic({
+        severity: "info",
+        code: "install-not-reversible",
+        message: `${action.packageName} was installed through ${action.packageManager}; a rollback restores files and will not uninstall it`,
+        remediation: null
+      }));
+    }
+  }
+  return outcome(action, status, { diagnostics, packageInventory });
 }
 
 // packages/core/dist/src/state/journal.js
@@ -2814,6 +3348,24 @@ async function verifyRestoration(fs, snapshots) {
   }
   return unrestored;
 }
+async function restorePackageInventories(records, runner, cwd) {
+  const diagnostics = [];
+  for (const record of records) {
+    if (record.kind !== "package-manager-install")
+      continue;
+    if (record.status !== "applied")
+      continue;
+    if (record.packageInventory === null || record.packageInventory === void 0)
+      continue;
+    const outcome2 = await restorePackageInventory({
+      capture: record.packageInventory,
+      runner,
+      cwd
+    });
+    diagnostics.push(...outcome2.diagnostics);
+  }
+  return diagnostics;
+}
 async function executeTransaction(request) {
   const startedAt = request.now();
   const entries = [];
@@ -2857,7 +3409,10 @@ async function executeTransaction(request) {
       restoreError = error instanceof Error ? error.message : String(error);
     }
     const unrestored = await verifyRestoration(request.fs, snapshots);
-    if (restoreError === null && unrestored.length === 0) {
+    const packageDiagnostics = await restorePackageInventories(applied, request.runner ?? null, request.projectRoot);
+    diagnostics.push(...packageDiagnostics);
+    const packageRestoreFailed = packageDiagnostics.some((entry) => entry.severity === "error");
+    if (restoreError === null && unrestored.length === 0 && !packageRestoreFailed) {
       diagnostics.push(diagnostic({
         severity: "info",
         code: "transaction-rolled-back",
@@ -2885,6 +3440,7 @@ async function executeTransaction(request) {
         status: "failed",
         snapshots: [],
         ownership: [],
+        packageInventory: null,
         diagnostics: [
           diagnostic({
             severity: "error",
@@ -2902,7 +3458,8 @@ async function executeTransaction(request) {
       status: result.status,
       snapshots: result.snapshots,
       ownership: result.ownership,
-      diagnostics: result.diagnostics
+      diagnostics: result.diagnostics,
+      packageInventory: result.packageInventory
     };
     entries.push(entry);
     applied.push(result);
@@ -2987,7 +3544,10 @@ async function rollbackTransaction(request) {
     restoreError = error instanceof Error ? error.message : String(error);
   }
   const unrestored = await verifyRestoration(request.fs, snapshots);
-  if (restoreError === null && unrestored.length === 0) {
+  const packageDiagnostics = await restorePackageInventories(journal.entries, request.runner ?? null, request.cwd ?? journal.projectRoot);
+  diagnostics.push(...packageDiagnostics);
+  const packageRestoreFailed = packageDiagnostics.some((entry) => entry.severity === "error");
+  if (restoreError === null && unrestored.length === 0 && !packageRestoreFailed) {
     journal.outcome = "rolled-back";
     journal.ownership = [];
     journal.finishedAt = request.now();
@@ -5004,20 +5564,47 @@ var MANIFEST3 = {
    * configuration must be able to exit 0. A declared limitation is not a problem, and reporting
    * it as one is the fastest way to teach users to ignore the exit code."
    *
-   * A single point rather than a range, matching the Codex adapter: one version was observed, so
-   * one version is claimed. An older 1.x reports `unknown-older`, which is a warning and not a
+   * A range now, because spike 9.1 observed two more: the CLI at `1.18.11` and OpenCode Desktop at
+   * `1.18.14`, both loading plugins from the same directories. The span is what was watched, not a
+   * guess that every 1.18.x behaves alike — and the two ends differ in a way that matters, which is
+   * exactly why both are named. An older 1.x reports `unknown-older`, which is a warning and not a
    * problem, and a newer one reports `unknown-newer` — which is then a true statement.
    */
-  testedVersions: { minimum: "1.18.9", maximum: "1.18.9" },
+  testedVersions: { minimum: "1.18.9", maximum: "1.18.14" },
   // RFC 0007: a managed provider can emit a receipt, but an adopted generated wrapper
   // has no externally observable receipt. The harness adapter alone therefore declares
   // the achievable baseline, not a promise about a provider it does not own.
   verificationTier: "config-only",
   versionCommand: { executable: "opencode", args: ["--version"] },
-  interceptionPoints: [{ scopeId: "tool-execute-after", eventName: "tool.execute.after" }],
+  interceptionPoints: [
+    { scopeId: "tool-execute-before", eventName: "tool.execute.before" },
+    { scopeId: "tool-execute-after", eventName: "tool.execute.after" }
+  ],
+  /**
+   * Two kinds of entry, because OpenCode has two ways to register a plugin and only one of them is
+   * a document.
+   *
+   * The `opencode.jsonc` files carry a `plugin` string array. The directories are auto-loaded: any
+   * module dropped in one is registered without being named anywhere, which is how both real
+   * integrations install — `rtk init -g --opencode` writes `.config/opencode/plugins/rtk.ts` and
+   * touches no JSON at all, and HarnessTrim's generated wrapper says in its own header not to
+   * reference it from `opencode.json`. An adapter that read only the array would report every such
+   * installation as absent, which is the state this file was in before spike 9.1.
+   *
+   * Both spellings are listed because both load. Spike 9.1 put a probe in each and one run fired
+   * both; the upstream documentation names the plural, the binary carries both strings, and the two
+   * shipped integrations disagree with each other about which to use.
+   *
+   * `markers` is the parser because there is nothing to parse: the presence of a file is the
+   * configuration, and its contents are a plugin module rather than a document this build reads.
+   */
   configFiles: [
     { path: ".config/opencode/opencode.jsonc", scope: "user", parser: "jsonc", primary: true },
-    { path: "opencode.jsonc", scope: "project", parser: "jsonc", primary: false }
+    { path: "opencode.jsonc", scope: "project", parser: "jsonc", primary: false },
+    { path: ".config/opencode/plugins", scope: "user", parser: "markers", primary: false },
+    { path: ".config/opencode/plugin", scope: "user", parser: "markers", primary: false },
+    { path: ".opencode/plugins", scope: "project", parser: "markers", primary: false },
+    { path: ".opencode/plugin", scope: "project", parser: "markers", primary: false }
   ],
   toolFamilies: [
     { id: "tool.execute", platforms: ["windows", "macos", "linux"], executesShellCommands: true }
@@ -5034,7 +5621,38 @@ function pluginEntries(document2) {
     return [];
   return document2["plugin"].filter((item) => typeof item === "string");
 }
+var PLUGIN_MODULE_PATTERN = /\.(ts|js|mjs|cjs|mts|cts)$/i;
+var PLUGIN_POINTS = ["tool-execute-before", "tool-execute-after"];
+async function resolvePluginDirectory(declaration, context) {
+  const path = resolveConfigPath(declaration, context);
+  const stat3 = await context.fs.stat(path);
+  if (stat3 === null || stat3.kind !== "directory") {
+    return {
+      declaration,
+      path,
+      exists: false,
+      parsed: false,
+      configuredPoints: [],
+      matchers: [],
+      commands: []
+    };
+  }
+  const modules = (await context.fs.readDirectory(path)).filter((entry) => PLUGIN_MODULE_PATTERN.test(entry));
+  return {
+    declaration,
+    path,
+    exists: true,
+    // A directory listing cannot fail to parse. `markers` declares that there is nothing to read.
+    parsed: true,
+    configuredPoints: modules.length > 0 ? [...PLUGIN_POINTS] : [],
+    // The plugin API sees every tool result; this is not a shell matcher.
+    matchers: modules.length > 0 ? ["tool.execute"] : [],
+    commands: modules.map((entry) => context.fs.join(path, entry))
+  };
+}
 async function resolveConfig3(declaration, context) {
+  if (declaration.parser === "markers")
+    return resolvePluginDirectory(declaration, context);
   const path = resolveConfigPath(declaration, context);
   const stat3 = await context.fs.stat(path);
   if (stat3 === null || stat3.kind !== "file") {
@@ -5066,7 +5684,9 @@ async function resolveConfig3(declaration, context) {
     path,
     exists: true,
     parsed: true,
-    configuredPoints: plugins.length > 0 ? ["tool-execute-after"] : [],
+    // A `plugin` array entry is the same kind of thing as a module in a plugin directory: a
+    // registration whose hooks are only known once it runs. Same claim, same reason.
+    configuredPoints: plugins.length > 0 ? [...PLUGIN_POINTS] : [],
     // The plugin API sees every tool result; this is not a shell matcher.
     matchers: plugins.length > 0 ? ["tool.execute"] : [],
     commands: plugins
@@ -5234,7 +5854,14 @@ var CLAUDE_ARTIFACT_DIGESTS = {
   "scaffold-fast/SKILL.md": "sha256:1a18d52c4d335fbd3f74e2559bc20d6346193a40eef7b85149f51f44f697d182"
 };
 var OPENCODE2 = harnessId("opencode");
+var MODE_CARRYING_HARNESSES = /* @__PURE__ */ new Set([
+  OPENCODE2,
+  harnessId("hermes"),
+  harnessId("pi"),
+  harnessId("omp")
+]);
 var HOOK_COMMAND_PATTERN = /(^|[\\/\s"'])harnesstrim(\.cmd|\.exe)?([\s"']|$)/i;
+var PLUGIN_MODULE_PATTERN2 = /(^|[\\/])harnesstrim\.(ts|js|mjs|cjs|mts|cts)$/i;
 var MANIFEST4 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
   id: HARNESSTRIM2,
@@ -5311,12 +5938,17 @@ var MANIFEST4 = {
     }
   ],
   metrics: {
-    // RFC 0005 §Importer degradation policy: `legacy` is the character-only `TrimEvent` JSONL, and
-    // it is "a supported steady state, not a warning". `native` would need upstream to expose token
-    // counts and native ids, which `0.0.5` does not.
+    // RFC 0005 §Importer degradation policy. `native` since PLAN §15 item 43d: the `0.1.0`
+    // telemetry lines carry a producer `eventId` and nullable token counts, so dedup uses the
+    // native ID and a token count is a token count where one exists. Legacy schema 0 lines
+    // still parse, stay `estimated-local`, and never merge with the native figures.
     source: "jsonl",
-    mode: "legacy",
-    locations: [".harnesstrim/metrics.jsonl", "~/.hermes/harnesstrim-metrics.jsonl"]
+    mode: "native",
+    // PLAN §15 item 25: Hermes has no adapter, tested range or tier, so the home-relative path that
+    // names it is not read. Item 30 readmits it together with the adapter and a matrix row; the
+    // registry assertion in `registries.test.ts` refuses a home-relative location that names a
+    // harness the registry does not know.
+    locations: [".harnesstrim/metrics.jsonl"]
   },
   delegatedInstallReview: {
     upstreamVersion: "0.0.7",
@@ -5330,7 +5962,195 @@ var MANIFEST4 = {
 var TESTED_UPSTREAM = "0.0.7";
 var TESTED_VERSIONS = { minimum: "0.0.5", maximum: TESTED_UPSTREAM };
 function identifiesCommand(command) {
-  return HOOK_COMMAND_PATTERN.test(command);
+  return HOOK_COMMAND_PATTERN.test(command) || PLUGIN_MODULE_PATTERN2.test(command);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function parseHarnessCapabilities(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const record = value;
+  const surfaces = record["surfaces"];
+  const writeSet = record["writeSet"];
+  const narrowing = record["narrowing"];
+  if (!isStringArray(surfaces) || !isStringArray(writeSet) || !Array.isArray(narrowing)) {
+    return null;
+  }
+  const flags = [];
+  for (const item of narrowing) {
+    if (typeof item !== "object" || item === null)
+      return null;
+    const flag = item["flag"];
+    const produces = item["produces"];
+    if (typeof flag !== "string" || typeof produces !== "string")
+      return null;
+    flags.push({ flag, produces });
+  }
+  return {
+    adapter: typeof record["adapter"] === "string" ? record["adapter"] : "",
+    surfaces,
+    writeSet,
+    narrowing: flags
+  };
+}
+function parseCapabilities(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const record = parsed;
+  const version2 = record["version"];
+  const harnesses = record["harnesses"];
+  if (typeof version2 !== "string" || typeof harnesses !== "object" || harnesses === null) {
+    return null;
+  }
+  const entries = {};
+  for (const [harness, value] of Object.entries(harnesses)) {
+    const entry = parseHarnessCapabilities(value);
+    if (entry === null)
+      return null;
+    entries[harness] = entry;
+  }
+  return { version: version2, harnesses: entries };
+}
+async function probeCapabilities(context) {
+  const outcome2 = await context.runner.run({
+    executable: "harnesstrim",
+    args: ["capabilities"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (outcome2.failure !== null || outcome2.exitCode !== 0) {
+    return {
+      capabilities: null,
+      evidence: [
+        evidence({
+          kind: "absence",
+          source: "harnesstrim capabilities",
+          detail: "did not answer with a machine-readable declaration"
+        })
+      ]
+    };
+  }
+  const capabilities = parseCapabilities(outcome2.stdout);
+  if (capabilities === null) {
+    return {
+      capabilities: null,
+      evidence: [
+        evidence({
+          kind: "version-output",
+          source: "harnesstrim capabilities",
+          path: outcome2.executablePath,
+          detail: "answered, but not with a declaration this build can read"
+        })
+      ]
+    };
+  }
+  return {
+    capabilities,
+    evidence: [
+      evidence({
+        kind: "version-output",
+        source: "harnesstrim capabilities",
+        path: outcome2.executablePath,
+        detail: `declared ${capabilities.version} for ${Object.keys(capabilities.harnesses).join(", ")}`
+      })
+    ]
+  };
+}
+var SURFACE_ANCHORS = {
+  "post-tool-use": "PostToolUse",
+  "tool-execute-after": "tool.execute.after"
+};
+function surfaceMatchesDeclaration(surface, declaration) {
+  const pointAnchor = SURFACE_ANCHORS[declaration.interceptionPoint];
+  if (pointAnchor !== void 0 && !surface.includes(pointAnchor))
+    return false;
+  if (declaration.toolFamily !== EVERY_TOOL_FAMILY && !surface.includes(declaration.toolFamily)) {
+    return false;
+  }
+  return true;
+}
+function writeSetPath(entry) {
+  return entry.replace(/\s*\([^)]*\)\s*$/, "").replaceAll("\\", "/");
+}
+function coveredBy(path, declared) {
+  const base = declared.endsWith("/") ? declared : `${declared}/`;
+  return path === declared || path.startsWith(base);
+}
+function driftWarning(message, remediation) {
+  return diagnostic({
+    severity: "warning",
+    code: "provider-capabilities-drift",
+    subject: "harnesstrim",
+    message,
+    remediation
+  });
+}
+function formatSurface(surface) {
+  return `${surface.toolFamily}/${surface.interceptionPoint}`;
+}
+function narrowable(capabilities) {
+  if (capabilities === null || capabilities === void 0)
+    return false;
+  const managed = MANIFEST4.harnesses.map((entry) => entry.harness);
+  return managed.every((harness) => {
+    const observed = capabilities.harnesses[harness];
+    return observed !== void 0 && observed.narrowing.length > 0;
+  });
+}
+function writeSetStillReviewed(capabilities, harness) {
+  const review = MANIFEST4.delegatedInstallReview;
+  if (review === null || capabilities === null)
+    return false;
+  const observed = capabilities.harnesses[harness];
+  if (observed === void 0)
+    return false;
+  const declared = observed.writeSet.map(writeSetPath);
+  const boundary = review.containmentBoundary.map(writeSetPath);
+  const everyDeclaredPathContained = declared.every((entry) => boundary.some((prefix) => coveredBy(entry, prefix)));
+  const everyReviewedPathCovered = review.reviewedWriteSet.every((reviewed) => declared.some((entry) => coveredBy(reviewed, entry)));
+  return everyDeclaredPathContained && everyReviewedPathCovered;
+}
+function compareCapabilities(manifest, capabilities) {
+  const warnings = [];
+  for (const declaration of manifest.capabilities) {
+    for (const harness of declaration.harnesses) {
+      const observed = capabilities.harnesses[harness];
+      if (observed === void 0) {
+        warnings.push(driftWarning(`the manifest declares ${declaration.capability} on ${harness}, but \`harnesstrim capabilities\` (${capabilities.version}) lists no ${harness} entry`, `Re-test the ${harness} integration: either the manifest is stale or ${harness} lost its HarnessTrim surface`));
+        continue;
+      }
+      const matched = declaration.surfaces.some((surface) => observed.surfaces.some((entry) => surfaceMatchesDeclaration(entry, surface)));
+      if (!matched) {
+        warnings.push(driftWarning(`the manifest records ${declaration.capability} on ${harness} over ${declaration.surfaces.map(formatSurface).join(", ")}, but \`harnesstrim capabilities\` (${capabilities.version}) reports ${observed.surfaces.length === 0 ? "no surfaces" : observed.surfaces.join(" | ")}`, `Re-test the ${harness} integration and update the manifest declaration`));
+      }
+    }
+  }
+  const review = manifest.delegatedInstallReview;
+  if (review === null)
+    return warnings;
+  const claude = capabilities.harnesses["claude"];
+  if (claude === void 0)
+    return warnings;
+  const declared = claude.writeSet.map(writeSetPath);
+  for (const reviewed of review.reviewedWriteSet) {
+    if (declared.some((entry) => coveredBy(reviewed, entry)))
+      continue;
+    warnings.push(driftWarning(`the reviewed write set records ${reviewed} at ${review.upstreamVersion}, but \`harnesstrim capabilities\` (${capabilities.version}) declares nothing covering it (${declared.length === 0 ? "nothing" : declared.join(", ")})`, `Re-review the write set at the installed version before delegating another install`));
+  }
+  const boundary = review.containmentBoundary.map(writeSetPath);
+  for (const entry of declared) {
+    if (boundary.some((prefix) => coveredBy(entry, prefix)))
+      continue;
+    warnings.push(driftWarning(`\`harnesstrim capabilities\` (${capabilities.version}) declares ${entry} for claude, 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"));
+  }
+  return warnings;
 }
 function harnessesWiredToHarnessTrim(configs) {
   const wired = /* @__PURE__ */ new Set();
@@ -5413,16 +6233,17 @@ async function probeExecutable(context) {
   };
 }
 function metricsLocations(context) {
-  return [
-    context.fs.join(context.projectRoot, ".harnesstrim", "metrics.jsonl"),
-    context.fs.join(context.paths.home, ".hermes", "harnesstrim-metrics.jsonl")
-  ];
+  return [context.fs.join(context.projectRoot, ".harnesstrim", "metrics.jsonl")];
 }
 async function detect4(context) {
   const probe = await probeExecutable(context);
+  const observed = probe.installed ? await probeCapabilities(context) : null;
   const configured = harnessesWiredToHarnessTrim(context.harnessConfigs);
   const warnings = [];
-  const evidenceItems = [...probe.evidence];
+  const evidenceItems = [...probe.evidence, ...observed?.evidence ?? []];
+  if (observed !== null && observed.capabilities !== null) {
+    warnings.push(...compareCapabilities(MANIFEST4, observed.capabilities));
+  }
   for (const harness of configured) {
     evidenceItems.push(evidence({
       kind: "config-entry",
@@ -5460,6 +6281,10 @@ async function detect4(context) {
     // circumstantial: PLAN §11 says Token Harness never installs it, so every installation it ever
     // sees is the user's.
     managedByTokenHarness: false,
+    // PLAN §15 item 46. Decided by the build in front of us, not by the manifest: a build that
+    // declares narrowing flags for every managed harness can be asked for the narrowed states
+    // §6.1 recorded as unproducible, and one that cannot answer keeps the `0.0.5` verdict.
+    assignable: observed?.capabilities === null ? false : narrowable(observed?.capabilities),
     evidence: evidenceItems,
     warnings
   };
@@ -5481,6 +6306,12 @@ function parseTrimEvent(line) {
   if (typeof ts !== "string" || typeof harness !== "string" || typeof before !== "number" || typeof after !== "number") {
     return null;
   }
+  const schemaVersion = typeof record["schemaVersion"] === "number" ? record["schemaVersion"] : 0;
+  if (schemaVersion > 1)
+    return null;
+  const eventId = schemaVersion === 1 && typeof record["eventId"] === "string" && record["eventId"] !== "" ? record["eventId"] : null;
+  if (schemaVersion === 1 && eventId === null)
+    return null;
   return {
     ts,
     harness,
@@ -5488,6 +6319,11 @@ function parseTrimEvent(line) {
     reducer: typeof record["reducer"] === "string" ? record["reducer"] : null,
     beforeChars: before,
     afterChars: after,
+    schemaVersion,
+    eventId,
+    changed: typeof record["changed"] === "boolean" ? record["changed"] : null,
+    beforeTokens: typeof record["beforeTokens"] === "number" ? record["beforeTokens"] : null,
+    afterTokens: typeof record["afterTokens"] === "number" ? record["afterTokens"] : null,
     ...typeof record["mode"] === "string" ? { mode: record["mode"] } : {}
   };
 }
@@ -5499,16 +6335,18 @@ function toEvent(event, sourceId, ordinal, line, context) {
   const instant = new Date(event.ts);
   if (Number.isNaN(instant.getTime()))
     return null;
+  const native = event.schemaVersion === 1;
   const dryrun = event.mode === "dryrun";
-  const eventId = synthesizeEventId(sourceId, ordinal, line);
+  const eventId = native ? event.eventId : synthesizeEventId(sourceId, ordinal, line);
+  const passThrough = native && event.changed === false;
+  const hasTokens = native && event.beforeTokens !== null && event.afterTokens !== null;
+  const hasUnprovenMode = native && MODE_CARRYING_HARNESSES.has(event.harness) && !hasTokens && !passThrough;
   return {
     schemaVersion: OPTIMIZATION_EVENT_SCHEMA_VERSION,
     eventId,
     timestamp: instant.toISOString(),
     provider: { id: HARNESSTRIM2, version: null },
     context: {
-      // The project the metrics file belongs to, which for the default location is the project it
-      // sits inside.
       projectId: context.projectIdFor(context.projectRoot),
       // Unlike RTK's database, a `TrimEvent` names its harness, so this is read rather than left
       // unknown.
@@ -5521,25 +6359,34 @@ function toEvent(event, sourceId, ordinal, line, context) {
       capability: event.harness === OPENCODE2 ? "tool.output.reduce" : "shell.output.reduce"
     },
     measurement: {
-      class: dryrun ? "counterfactual" : "estimated-local",
+      class: dryrun || hasUnprovenMode ? "counterfactual" : hasTokens ? "exact-local" : "estimated-local",
       beforeChars: event.beforeChars,
       afterChars: event.afterChars,
-      // RFC 0005: "never derived silently". `0.0.5` counts characters and nothing else.
-      beforeTokens: null,
-      afterTokens: null,
+      // RFC 0005: "never derived silently". `0.0.5` counts characters and nothing else; the
+      // `0.1.0` producer's counts are used as they are because a token count is a token count
+      // where one exists.
+      beforeTokens: hasTokens ? event.beforeTokens : null,
+      afterTokens: hasTokens ? event.afterTokens : null,
       tokenizer: null,
       confidenceLow: null,
       confidenceHigh: null
     },
     outcome: {
-      // A dryrun leaves `output.output` untouched, so nothing the model saw changed.
-      changed: !dryrun && event.afterChars !== event.beforeChars,
-      bypassReason: dryrun ? "dryrun" : event.afterChars === event.beforeChars ? "no-reduction-applied" : null,
+      // A dryrun leaves `output.output` untouched; a native line states whether its attempt
+      // actually changed the output. A native line whose mode the envelope cannot carry is
+      // deliberately not asserted as a change: the figure may describe a dryrun, and reporting
+      // `changed: true` would claim the model received fewer bytes than it did.
+      changed: dryrun || hasUnprovenMode ? false : native ? event.changed ?? true : event.afterChars !== event.beforeChars,
+      bypassReason: dryrun ? "dryrun" : (
+        // Same reason value as the diagnostic code for the residual ambiguity: nothing refutes a
+        // dryrun, and nothing proves one, so the bypass is the envelope's own silence.
+        hasUnprovenMode ? "mode-unresolved" : native ? passThrough ? "pass-through" : null : event.afterChars === event.beforeChars ? "no-reduction-applied" : null
+      ),
       originalReference: null,
       latencyMs: null,
       errorCode: null
     },
-    source: { nativeEventId: null, importedAt: context.now() }
+    source: { nativeEventId: native ? eventId : null, importedAt: context.now() }
   };
 }
 async function verify4(context) {
@@ -5590,7 +6437,7 @@ async function verify4(context) {
   const agents = context.fs.join(context.projectRoot, "AGENTS.md");
   if (await context.fs.stat(agents) !== null) {
     const text = new TextDecoder().decode(await context.fs.readFile(agents));
-    if (identifiesCommand(text)) {
+    if (HOOK_COMMAND_PATTERN.test(text)) {
       checks.push({
         id: "instruction-path-present",
         status: "info",
@@ -5626,6 +6473,8 @@ async function collectMetrics(context, store) {
   let skipped = 0;
   let lastCursor = null;
   let readAny = false;
+  let sawNative = false;
+  let unprovableModeEvents = 0;
   for (const path of metricsLocations(context)) {
     const stat3 = await context.fs.stat(path);
     if (stat3 === null)
@@ -5676,6 +6525,10 @@ async function collectMetrics(context, store) {
         ordinal += 1;
         continue;
       }
+      if (parsed.schemaVersion === 1)
+        sawNative = true;
+      if (event.outcome.bypassReason === "mode-unresolved")
+        unprovableModeEvents += 1;
       events.push(event);
       lastLine = trimmed;
       ordinal += 1;
@@ -5727,12 +6580,26 @@ async function collectMetrics(context, store) {
       diagnostics
     };
   }
+  if (unprovableModeEvents > 0) {
+    diagnostics.push(diagnostic({
+      severity: "info",
+      code: "provider-metrics-mode-unresolved",
+      message: `${String(unprovableModeEvents)} native event${unprovableModeEvents === 1 ? "" : "s"} from a mode-carrying harness could not be classed as realized: schema 1 carries no reduction mode`,
+      remediation: "Treat these figures as counterfactual; only OpenCode can later prove its mode from the configured plugin option"
+    }));
+  }
   return {
     providerId: HARNESSTRIM2,
-    // RFC 0005 §Importer degradation policy: character-only events are `legacy`, and "running in
-    // legacy mode is a supported steady state, not a warning".
-    mode: "legacy",
-    source: `harnesstrim TrimEvent JSONL (${TESTED_UPSTREAM} shape)`,
+    // RFC 0005 §Importer degradation policy, decided by what this run read: `native` when the
+    // file carried schema 1 events with producer IDs, `legacy` when it only had the character
+    // stream. Legacy inside a native run is not a problem — those lines are older files.
+    //
+    // A native stream whose mode-carrying harness lines cannot prove a realized reduction (no
+    // tokens, no pass-through) is `native-with-residue`: the import is native, but a part of it
+    // could not be classed as realized, and the count above qualifies exactly how much. A bare
+    // `native` must keep meaning "everything was classed".
+    mode: sawNative && unprovableModeEvents > 0 ? "native-with-residue" : sawNative ? "native" : "legacy",
+    source: `harnesstrim TrimEvent JSONL (schema 0 and schema 1)`,
     imported,
     skipped,
     cursor: lastCursor,
@@ -5769,7 +6636,12 @@ async function plan(context, request) {
     return { providerId: HARNESSTRIM2, desiredState: "absent", actions };
   }
   const installed = await probeExecutable(context);
-  if (installed.version !== TESTED_UPSTREAM) {
+  if (!installed.installed) {
+    return { providerId: HARNESSTRIM2, desiredState: "configured", actions: [] };
+  }
+  const observed = await probeCapabilities(context);
+  const reviewed = observed.capabilities === null ? installed.version === TESTED_UPSTREAM : writeSetStillReviewed(observed.capabilities, CLAUDE2);
+  if (!reviewed) {
     return { providerId: HARNESSTRIM2, desiredState: "configured", actions: [] };
   }
   const review = MANIFEST4.delegatedInstallReview;
@@ -5819,6 +6691,7 @@ var harnesstrimAdapter = {
 
 // packages/adapters/dist/src/providers/rtk-plan.js
 var RTK_HOOK_COMMAND_PREFIX = "rtk hook";
+var HOOK_LIST_HARNESSES = /* @__PURE__ */ new Set(["claude"]);
 function hookListPointer(eventName) {
   return `hooks.${eventName.replace(/\./g, "\\.")}`;
 }
@@ -5834,6 +6707,8 @@ function planTargets(context, request) {
     const harness = request.harnesses.find((entry) => entry.id === owned.scope.harness);
     if (harness === void 0)
       continue;
+    if (!HOOK_LIST_HARNESSES.has(harness.id))
+      continue;
     const point = harness.interceptionPoints.find((entry) => entry.scopeId === owned.scope.interceptionPoint);
     if (point === void 0)
       continue;
@@ -5966,11 +6841,11 @@ function installAction(context, manifest) {
       channel.digestAvailable ? "the release artifact carries a digest that will be verified" : "this channel publishes no digest, so the artifact cannot be verified by content"
     ],
     postconditions: ["`rtk --version` reports a version inside the tested range"],
-    // Not `package-inventory`: that promises an inventory-based reversal nothing implements. RFC
-    // 0004 allows rollback only by restoring snapshots, "never by inventing an uninstall command",
-    // and a package is not a file — so an installed package survives a rollback and the executor
-    // says so rather than letting the report imply otherwise.
-    rollbackData: "none",
+    // The declared value the executor now implements (RFC 0009 §Initial delivery order item 1):
+    // the executor captures whatever the channel has installed before the install runs, and a
+    // rollback restores that captured version through the same channel. `none` is left only for
+    // channels this build cannot ask about — there the executor says the package stayed instead.
+    rollbackData: channelCanReportInventory(channel.id) ? "package-inventory" : "none",
     explanation: `Install RTK through ${channel.id}`,
     packageManager: channel.id,
     // The channel's own name for the package, because they differ: `rtk-ai.rtk` on winget and
@@ -6009,6 +6884,7 @@ function buildRtkPlan(input) {
 // packages/adapters/dist/src/providers/rtk.js
 var RTK2 = providerId("rtk");
 var CLAUDE3 = harnessId("claude");
+var OPENCODE3 = harnessId("opencode");
 var MANIFEST5 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
   id: RTK2,
@@ -6047,10 +6923,53 @@ var MANIFEST5 = {
         sourceReference: "docs/spikes/2.5-live-verification-log.md",
         upstreamVersion: "0.42.0"
       }
+    },
+    /**
+     * OpenCode, from spike 9.1.
+     *
+     * Separate entries rather than adding `OPENCODE` to the two above, because the surface is not
+     * the same one: RTK reaches Claude Code through a `PreToolUse` hook matching `Bash`, and
+     * OpenCode through a plugin on `tool.execute.before`. A capability entry names one surface
+     * list, and merging these would claim that RTK serves `Bash/pre-tool-use` on OpenCode — a
+     * point OpenCode does not have.
+     *
+     * `shell.command.rewrite` and `shell.output.reduce` again arrive together, for the reason they
+     * do on Claude Code: the plugin calls `rtk rewrite`, and the rewritten command is what filters
+     * its own output. One interception point, two capabilities.
+     */
+    {
+      capability: "shell.command.rewrite",
+      mode: "exclusive",
+      harnesses: [OPENCODE3],
+      // `tool.execute` is the family the harness manifest declares as shell-executing. The plugin
+      // narrows to `tool === "bash" || tool === "shell"` inside that family, which is every shell
+      // route OpenCode exposes — unlike Claude Code on Windows, there is no second one to miss.
+      surfaces: [{ toolFamily: "tool.execute", interceptionPoint: "tool-execute-before" }],
+      evidence: {
+        sourceReference: "docs/spikes/9.1-rtk-opencode-observation-log.md",
+        upstreamVersion: "0.44.0"
+      }
+    },
+    {
+      capability: "shell.output.reduce",
+      mode: "exclusive",
+      harnesses: [OPENCODE3],
+      surfaces: [{ toolFamily: "tool.execute", interceptionPoint: "tool-execute-before" }],
+      evidence: {
+        sourceReference: "docs/spikes/9.1-rtk-opencode-observation-log.md",
+        upstreamVersion: "0.44.0"
+      }
     }
   ],
   platforms: [
-    { os: "windows", wsl: false, supported: true, limitation: null },
+    {
+      os: "windows",
+      wsl: false,
+      supported: true,
+      // Spike 9.1. Named on Windows alone because Windows is where Desktop was run; the same
+      // defect on another platform's Desktop build would be a guess until someone watches it.
+      limitation: "RTK's OpenCode plugin is inert under OpenCode Desktop, which supplies no `$` shell helper to plugins, so the plugin's own guard disables it silently"
+    },
     { os: "linux", wsl: true, supported: true, limitation: null },
     { os: "macos", wsl: false, supported: true, limitation: null },
     { os: "linux", wsl: false, supported: true, limitation: null }
@@ -6060,6 +6979,31 @@ var MANIFEST5 = {
       harness: CLAUDE3,
       testedVersions: { minimum: "2.0.0", maximum: "2.1.212" },
       verificationTier: "canary"
+    },
+    {
+      harness: OPENCODE3,
+      // Spike 9.1 watched interception on the CLI at `1.18.11` and watched it fail on Desktop at
+      // `1.18.14`. The range covers both because both were observed; the failure is a declared
+      // platform limitation below rather than a narrower range, because it is a property of the
+      // host application and not of the OpenCode version — the same 1.18.x plugin loads in both.
+      testedVersions: { minimum: "1.18.11", maximum: "1.18.14" },
+      /**
+       * `config-only`, even though spike 9.1 watched a canary-grade interception here — the counter
+       * moved by exactly the number of shell calls the OpenCode session made.
+       *
+       * A tier is what `verify` can prove on the user's machine, not what a spike proved once on a
+       * clean one. RTK's receipt is its history database, and the `commands` table carries
+       * `timestamp`, token counts, `exec_time_ms`, and `project_path` — no harness column, and no
+       * column standing in for one. The spike could attribute those rows because it ran OpenCode
+       * alone in a scratch directory and read the counter either side; `verify` runs where both
+       * harnesses are wired to the same binary and writing into the same table, and cannot say
+       * which of them a row came from.
+       *
+       * Declaring `canary` here would credit RTK's whole command history to whichever harness the
+       * reader happened to be looking at. Claude Code keeps `canary` because its own hook receipt
+       * is per-harness; this one is provider-wide, and RFC 0007 asks the question per harness.
+       */
+      verificationTier: "config-only"
     }
   ],
   installationChannels: [
@@ -6103,9 +7047,10 @@ var MANIFEST5 = {
   },
   delegatedInstallReview: null
 };
-var TESTED_VERSIONS2 = { minimum: "0.40.0", maximum: "0.42.0" };
+var TESTED_VERSIONS2 = { minimum: "0.40.0", maximum: "0.44.0" };
 var VERSION_PATTERN5 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
 var HOOK_COMMAND_PATTERN2 = /(^|[\\/\s"'])rtk(\.exe)?([\s"']|$)/i;
+var PLUGIN_MODULE_PATTERN3 = /(^|[\\/])rtk\.(ts|js|mjs|cjs|mts|cts)$/i;
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -6148,7 +7093,7 @@ function parseRtkAnalytics(text) {
 function harnessesWiredToRtk(configs) {
   const wired = /* @__PURE__ */ new Set();
   for (const config of configs) {
-    if (config.commands.some((command) => HOOK_COMMAND_PATTERN2.test(command))) {
+    if (config.commands.some((command) => identifiesCommand2(command))) {
       wired.add(config.harnessId);
     }
   }
@@ -6264,13 +7209,32 @@ async function detect5(context) {
     versionVerdict: version2.verdict,
     configuredHarnesses: configured,
     unmanagedHarnessesConfigured: [],
-    // RFC 0002 §Providers may exceed the managed surface. RTK's manifest covers Claude
-    // Code only, so the qualifier RFC 0006's doctor transcript uses for HarnessTrim does
-    // not apply here.
+    /**
+     * RFC 0002 §Providers may exceed the managed surface.
+     *
+     * The field asks whether this manifest names a harness with no adapter behind it. It names two,
+     * Claude Code and OpenCode, and both are managed — so the qualifier RFC 0006's doctor transcript
+     * uses for HarnessTrim does not apply, and the report says "not configured for any harness"
+     * without hedging.
+     *
+     * `rtk init --agent` separately targets Cursor, Windsurf, Cline, Kilo Code, Antigravity, Kimi,
+     * Pi, Hermes, and Droid. That is RTK exceeding *Token Harness*, not this manifest exceeding the
+     * managed set, and it stays out of the flag: claiming those here would make the resolver
+     * responsible for harnesses this build has no adapter to inspect.
+     */
     supportsUnmanagedHarnesses: false,
     // RFC 0004 §Brownfield adoption: nothing has been applied by Token Harness yet, so
     // every installation it finds is the user's.
     managedByTokenHarness: false,
+    /**
+     * Always, and independent of the observed version.
+     *
+     * RTK's assignment is produced by this build writing the hook itself — `rtk-plan.ts` appends
+     * the entry — so nothing about the installed `rtk` decides whether the state is reachable.
+     * That is the difference from HarnessTrim, whose assignment is produced by *its* installer and
+     * therefore depends on which flags that installer has.
+     */
+    assignable: true,
     evidence: evidenceItems,
     warnings
   };
@@ -6392,7 +7356,7 @@ function toEvent2(row2, context) {
     context: {
       // An empty `project_path` means RTK recorded no directory; attributing the event to
       // the directory `metrics` happens to run in would invent an attribution.
-      projectId: projectPath === null || projectPath === "" ? "p_unattributed" : context.projectIdFor(projectPath),
+      projectId: projectPath === null || projectPath === "" ? UNATTRIBUTED_PROJECT_ID : context.projectIdFor(projectPath),
       // RTK proxies commands for whichever harness invoked it and does not record which.
       // The hook that wires it is per harness, but a *row* carries no harness, and reading
       // one off the current configuration would attribute months of history to today's
@@ -6582,7 +7546,7 @@ async function collectMetrics2(context, store) {
 }
 var SOURCE_LABEL = "rtk history.db (commands)";
 function identifiesCommand2(command) {
-  return HOOK_COMMAND_PATTERN2.test(command);
+  return HOOK_COMMAND_PATTERN2.test(command) || PLUGIN_MODULE_PATTERN3.test(command);
 }
 async function plan2(context, request) {
   const version2 = await readVersion(context);
@@ -6611,7 +7575,6 @@ function listProviderAdapters() {
 
 // apps/cli/dist/src/commands/plan.js
 var DEFAULT_PROFILE = "safe";
-var ASSIGNABLE_PROVIDERS = ["rtk"];
 async function computePlan(context) {
   const diagnostics = [];
   const providerAdapters = listProviderAdapters().filter((adapter) => context.provider === null || adapter.manifest.id === context.provider);
@@ -6638,11 +7601,6 @@ async function computePlan(context) {
       harnessConfigs.push(...inspection.summaries);
     }
   }
-  const providers = providerAdapters.map((adapter) => ({
-    id: adapter.manifest.id,
-    capabilities: adapter.manifest.capabilities,
-    assignable: ASSIGNABLE_PROVIDERS.includes(adapter.manifest.id)
-  }));
   const providerContext = detectionContext === null || context.adapters === null ? null : {
     ...detectionContext,
     harnessConfigs,
@@ -6650,12 +7608,19 @@ async function computePlan(context) {
     localDatabase: context.adapters.localDatabase,
     projectIdFor: context.adapters.projectIdFor
   };
+  const assignable = /* @__PURE__ */ new Map();
   if (providerContext !== null) {
     for (const adapter of providerAdapters) {
       const detection = await adapter.detect(providerContext);
       versions.providers[adapter.manifest.id] = detection.version;
+      assignable.set(adapter.manifest.id, detection.assignable);
     }
   }
+  const providers = providerAdapters.map((adapter) => ({
+    id: adapter.manifest.id,
+    capabilities: adapter.manifest.capabilities,
+    assignable: assignable.get(adapter.manifest.id) ?? false
+  }));
   const resolution = resolveOwnership({
     profile,
     harnesses: present,
@@ -6665,7 +7630,9 @@ async function computePlan(context) {
     harness: context.harness
   });
   const actions = [];
+  const blocked = [];
   if (providerContext !== null) {
+    const rows = context.compatibilityRows ?? COMPATIBILITY_ROWS;
     for (const adapter of providerAdapters) {
       const owned = resolution.ownership.filter((entry) => entry.owner === adapter.manifest.id);
       if (owned.length === 0 && adapter.plansWithoutOwnership !== true)
@@ -6675,7 +7642,35 @@ async function computePlan(context) {
         harnesses: present,
         desiredState: "configured"
       });
-      actions.push(...providerPlan.actions);
+      if (providerPlan.actions.length === 0)
+        continue;
+      const touched = [...new Set(owned.map((entry) => entry.scope.harness))];
+      if (touched.length === 0)
+        touched.push(...present.map((harness) => harness.id));
+      let admitted = true;
+      for (const harness of touched) {
+        const admission = admitManagedMutation(rows, {
+          provider: adapter.manifest.id,
+          providerVersion: versions.providers[adapter.manifest.id] ?? null,
+          harness,
+          harnessVersion: versions.harnesses[harness] ?? null,
+          os: context.platform.os,
+          wsl: context.platform.isWsl
+        });
+        if (admission.state !== "admitted") {
+          admitted = false;
+          blocked.push({
+            provider: adapter.manifest.id,
+            providerVersion: versions.providers[adapter.manifest.id] ?? null,
+            harness,
+            harnessVersion: versions.harnesses[harness] ?? null,
+            verdict: admission.verdict,
+            missing: admission.missing
+          });
+        }
+      }
+      if (admitted)
+        actions.push(...providerPlan.actions);
     }
   }
   const report = {
@@ -6733,7 +7728,7 @@ async function computePlan(context) {
       remediation: null
     }));
   }
-  if (resolution.ownership.length > 0 && actions.length === 0) {
+  if (resolution.ownership.length > 0 && actions.length === 0 && blocked.length === 0) {
     diagnostics.push(diagnostic({
       severity: "info",
       code: "already-in-desired-state",
@@ -6741,6 +7736,14 @@ async function computePlan(context) {
       remediation: null
     }));
   }
+  for (const entry of blocked) {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      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"
+    }));
+  }
   for (const conflict of resolution.conflicts) {
     diagnostics.push(diagnostic({
       severity: "error",
@@ -6749,7 +7752,7 @@ async function computePlan(context) {
       remediation: conflict.remediation
     }));
   }
-  return { report, versions, diagnostics, present, harnessConfigs };
+  return { report, versions, diagnostics, present, harnessConfigs, blocked };
 }
 async function persist(context, computed) {
   if (context.adapters === null || context.stateRoot === null)
@@ -6774,7 +7777,7 @@ async function runPlan(context) {
   const computed = await computePlan(context);
   const persisted = await persist(context, computed);
   const report = { ...computed.report, persisted };
-  const exitCode = report.conflicts.length > 0 ? EXIT_CODES["blocked-by-conflict"] : EXIT_CODES.ok;
+  const exitCode = computed.blocked.length > 0 ? EXIT_CODES["unsupported-environment"] : report.conflicts.length > 0 ? EXIT_CODES["blocked-by-conflict"] : EXIT_CODES.ok;
   return commandResult({
     command: "plan",
     exitCode,
@@ -6845,6 +7848,9 @@ async function runApply(context) {
   const diagnostics = [];
   const computed = await computePlan(context);
   diagnostics.push(...computed.diagnostics);
+  if (computed.blocked.length > 0) {
+    return finish("rejected", EXIT_CODES["unsupported-environment"], emptyReport("rejected"), diagnostics);
+  }
   if (computed.report.conflicts.length > 0) {
     return finish("rejected", EXIT_CODES["blocked-by-conflict"], emptyReport("rejected"), diagnostics);
   }
@@ -6999,10 +8005,40 @@ async function runDoctor(context) {
     projectIdFor: context.adapters?.projectIdFor ?? (() => "p_unattributed")
   })));
   const problemCount = harnesses.filter(isBroken).length + providers.filter(isBroken).length + [...harnesses, ...providers].filter((detection) => detection.versionVerdict === "unknown-newer").length;
+  const rows = context.compatibilityRows ?? COMPATIBILITY_ROWS;
+  const providersWithCoverage = providers.map((detection) => {
+    if (detection.state !== "configured" || detection.configuredHarnesses.length === 0) {
+      return detection;
+    }
+    const uncovered = detection.configuredHarnesses.flatMap((harness) => {
+      const harnessVersion = harnesses.find((candidate) => candidate.harnessId === harness)?.version ?? null;
+      const admission = admitManagedMutation(rows, {
+        provider: detection.providerId,
+        providerVersion: detection.version,
+        harness,
+        harnessVersion,
+        os: context.platform.os,
+        wsl: context.platform.isWsl
+      });
+      if (admission.state === "admitted")
+        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"
+        })
+      ];
+    });
+    if (uncovered.length === 0)
+      return detection;
+    return { ...detection, warnings: [...detection.warnings, ...uncovered] };
+  });
   const report = {
     platform: context.platform,
     harnesses,
-    providers,
+    providers: providersWithCoverage,
     problemCount
   };
   return commandResult({
@@ -7094,14 +8130,42 @@ async function runMetrics(context) {
       }
     }
   }
+  const projectId = context.adapters === null ? null : context.adapters.projectIdFor(context.projectRoot);
   const events = [];
   for await (const event of store.query({
     since: window.sinceInstant,
     until: window.untilInstant,
+    ...projectId === null ? {} : { projectId },
     ...context.provider === null ? {} : { providerIds: [context.provider] }
   })) {
     events.push(event);
   }
+  if (projectId === null) {
+    diagnostics.push(diagnostic({
+      severity: "info",
+      code: "metrics-not-project-scoped",
+      message: "This report covers every project in the store: no project identity was available",
+      remediation: null
+    }));
+  } else {
+    let unattributed = 0;
+    for await (const _event of store.query({
+      since: window.sinceInstant,
+      until: window.untilInstant,
+      projectId: UNATTRIBUTED_PROJECT_ID,
+      ...context.provider === null ? {} : { providerIds: [context.provider] }
+    })) {
+      unattributed += 1;
+    }
+    if (unattributed > 0) {
+      diagnostics.push(diagnostic({
+        severity: "info",
+        code: "metrics-unattributed-excluded",
+        message: `${String(unattributed)} operation${unattributed === 1 ? "" : "s"} named no project and are excluded from this report`,
+        remediation: null
+      }));
+    }
+  }
   const report = aggregateEvents({
     events,
     windowStart: window.windowStart,
@@ -7226,7 +8290,12 @@ async function runRollback(context) {
     fs,
     snapshots: built.store,
     journal: built.journal,
-    now: context.now
+    now: context.now,
+    // Package inventories, when the transaction captured any: restoring a package needs the same
+    // process runner the install used. Absent, the rollback reports those packages as not
+    // restored instead of attempting a silent reinstall.
+    runner: context.adapters.runner,
+    cwd: context.projectRoot
   });
   diagnostics.push(...result.diagnostics);
   const report = empty(result.exitCode === 0 ? "rolled-back" : "dirty");
@@ -7348,7 +8417,6 @@ async function runUninstall(context) {
 }
 
 // apps/cli/dist/src/commands/status.js
-var ASSIGNABLE_PROVIDERS2 = ["rtk"];
 async function runStatus(context) {
   const report = {
     platform: context.platform,
@@ -7386,12 +8454,8 @@ async function runStatus(context) {
     configs.push(...inspection.summaries);
   }
   const providerAdapters = listProviderAdapters();
-  const providers = providerAdapters.map((adapter) => ({
-    id: adapter.manifest.id,
-    capabilities: adapter.manifest.capabilities,
-    assignable: ASSIGNABLE_PROVIDERS2.includes(adapter.manifest.id)
-  }));
   const observedVersions = {};
+  const providers = [];
   for (const adapter of providerAdapters) {
     const detection = await adapter.detect({
       ...detectionContext,
@@ -7401,6 +8465,11 @@ async function runStatus(context) {
       projectIdFor: context.adapters.projectIdFor
     });
     observedVersions[adapter.manifest.id] = detection.version;
+    providers.push({
+      id: adapter.manifest.id,
+      capabilities: adapter.manifest.capabilities,
+      assignable: detection.assignable
+    });
   }
   const resolution = resolveOwnership({
     profile: "safe",
@@ -7461,14 +8530,15 @@ function upgradeAction(input) {
     ],
     postconditions: [`${input.packageName} reports ${input.target}`],
     /**
-     * `none`, and the consequence is worth stating where a reviewer sees it.
+     * `package-inventory` where the channel can report what is installed, `none` otherwise.
      *
      * An update replaces a binary. Rolling the transaction back restores files and leaves the new
-     * version in place, so the executor's `install-not-reversible` diagnostic is not boilerplate
-     * here — it is the difference between the machine being restored and the *configuration*
-     * being restored.
+     * version in place, so the executor's receipt is not boilerplate here — it is the difference
+     * between the machine being restored and the *configuration* being restored. With an
+     * inventory-capturing channel the rollback also reinstalls the previous version, and the
+     * receipt says per package whether that reinstall took.
      */
-    rollbackData: "none",
+    rollbackData: channelCanReportInventory(input.channel) ? "package-inventory" : "none",
     explanation: `Update ${input.packageName} from ${input.installed} to ${input.target} through ${input.channel}`,
     packageManager: input.channel,
     packageName: input.packageName,
@@ -7741,11 +8811,12 @@ async function runVerify(context) {
       presentHarnesses
     );
     for (const harnessId2 of harnesses) {
+      const declaredTier = adapter.manifest.harnesses.find((entry) => entry.harness === harnessId2)?.verificationTier ?? verification.declaredTier;
       results.push({
         providerId: adapter.manifest.id,
         harnessId: harnessId2,
-        status: statusFor(verification.achievedTier, verification.declaredTier),
-        declaredTier: verification.declaredTier,
+        status: statusFor(verification.achievedTier, declaredTier),
+        declaredTier,
         managedByTokenHarness: MANAGED_PROVIDERS.includes(adapter.manifest.id),
         checks: verification.checks
       });
@@ -7942,7 +9013,8 @@ function renderApplyReport(report, context, command = "apply") {
       lines.push(`  ${displayPath(path, context.home)}`);
     lines.push("");
   }
-  lines.push((OUTCOME_LINES[command] ?? OUTCOME_LINES["apply"])?.[report.outcome] ?? "");
+  const removedNothing = command === "uninstall" && report.outcome === "committed" && report.results.length > 0 && report.results.every((result) => result.status !== "applied");
+  lines.push(removedNothing ? "Removed nothing: no owned entry was recognised. Everything is untouched." : (OUTCOME_LINES[command] ?? OUTCOME_LINES["apply"])?.[report.outcome] ?? "");
   return document(lines);
 }
 
@@ -8609,7 +9681,7 @@ function usageText(topic) {
 }
 
 // apps/cli/dist/src/version.js
-var TOOL_VERSION = "0.1.1";
+var TOOL_VERSION = "0.1.2";
 
 // apps/cli/dist/src/run.js
 var DEFAULT_COMMANDS = {
@@ -8786,7 +9858,8 @@ async function run(options) {
     until: invocation.options.until,
     planId: invocation.options.plan,
     confirmed: invocation.options.yes,
-    metrics: options.metrics ?? null
+    metrics: options.metrics ?? null,
+    compatibilityRows: options.compatibilityRows ?? null
   };
   const table = options.commands ?? DEFAULT_COMMANDS;
   let result;