token-harness 0.1.1 → 0.1.3

package/token-harness.mjs

@@ -97,18 +97,138 @@ function compareVersions(a, b) {
   return comparePrerelease(a.prerelease, b.prerelease);
 }
 function classifyVersion(observed, range) {
-  const version2 = parseSemanticVersion(observed);
+  const version3 = parseSemanticVersion(observed);
   const minimum = parseSemanticVersion(range.minimum);
-  if (version2 === null || minimum === null)
+  if (version3 === null || minimum === null)
     return "unparseable";
-  if (compareVersions(version2, minimum) < 0)
+  if (compareVersions(version3, minimum) < 0)
     return "below-range";
   if (range.maximum === null)
     return "in-range";
   const maximum = parseSemanticVersion(range.maximum);
   if (maximum === null)
     return "unparseable";
-  return compareVersions(version2, maximum) > 0 ? "unknown-newer" : "in-range";
+  return compareVersions(version3, 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"
+  },
+  {
+    harness: "codex",
+    harnessVersion: { minimum: "0.146.0", maximum: "0.146.0" },
+    provider: "harnesstrim",
+    providerVersion: "0.1.0",
+    platform: { os: "windows", wsl: false, supported: true, limitation: null },
+    // The same shape as the Claude skills row, and for the same reason: the install writes skill
+    // files rather than a document this build parses, so the schema it depends on is the directory
+    // layout. A separate id because the directory is `.codex/skills` and the protected paths differ.
+    configSchema: "codex-skills-directory",
+    fixture: "tests/fixtures/rows/harnesstrim-codex-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
@@ -207,6 +327,7 @@ function harnessId(value) {
   }
   return value;
 }
+var UNATTRIBUTED_PROJECT_ID = "p_unattributed";
 
 // packages/core/dist/src/domain/manifest.js
 var MANIFEST_SCHEMA_VERSION = 1;
@@ -587,13 +708,14 @@ function resolveOwnership(input) {
             });
             continue;
           }
-          if (!provider.assignable) {
+          if (!provider.assignableHarnesses.has(harness.id)) {
+            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} on ${harness.id} but no installer state this build could observe produces it there` : `${provider.id} ${observed} implements ${capability} on ${harness.id} but no installer state at that version produces it there`,
                 "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 +756,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 +767,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 +902,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 +967,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];
@@ -820,21 +1039,21 @@ function validateStoredPlan(input) {
       detail: `the plan was computed for ${stored.projectRoot} and this invocation is in ${input.projectRoot}`
     });
   }
-  for (const [id, version2] of Object.entries(stored.versions.providers)) {
+  for (const [id, version3] of Object.entries(stored.versions.providers)) {
     const current = input.versions.providers[id];
-    if (current !== version2) {
+    if (current !== version3) {
       rejections.push({
         reason: "plan-version-drift",
-        detail: `${id} was ${version2 ?? "absent"} when the plan was made and is now ${current ?? "absent"}`
+        detail: `${id} was ${version3 ?? "absent"} when the plan was made and is now ${current ?? "absent"}`
       });
     }
   }
-  for (const [id, version2] of Object.entries(stored.versions.harnesses)) {
+  for (const [id, version3] of Object.entries(stored.versions.harnesses)) {
     const current = input.versions.harnesses[id];
-    if (current !== version2) {
+    if (current !== version3) {
       rejections.push({
         reason: "plan-version-drift",
-        detail: `${id} was ${version2 ?? "absent"} when the plan was made and is now ${current ?? "absent"}`
+        detail: `${id} was ${version3 ?? "absent"} when the plan was made and is now ${current ?? "absent"}`
       });
     }
   }
@@ -1121,7 +1340,7 @@ function resolveMetricsWindow(input) {
 var INSTALL_COMMANDS = {
   winget: {
     executable: "winget",
-    args: (packageName, version2) => [
+    args: (packageName, version3) => [
       "install",
       "--id",
       packageName,
@@ -1131,16 +1350,16 @@ var INSTALL_COMMANDS = {
       "--silent",
       "--accept-package-agreements",
       "--accept-source-agreements",
-      ...version2 === null ? [] : ["--version", version2]
+      ...version3 === null ? [] : ["--version", version3]
     ],
     verified: true
   },
   cargo: {
     executable: "cargo",
-    args: (packageName, version2) => [
+    args: (packageName, version3) => [
       "install",
       packageName,
-      ...version2 === null ? [] : ["--version", version2]
+      ...version3 === null ? [] : ["--version", version3]
     ],
     verified: false
   }
@@ -1258,8 +1477,8 @@ async function queryAvailableVersion(input) {
     }));
     return { status: "failed", version: null, destination, diagnostics };
   }
-  const version2 = recipe.parse(outcome2.stdout);
-  if (version2 === null) {
+  const version3 = recipe.parse(outcome2.stdout);
+  if (version3 === null) {
     diagnostics.push(diagnostic({
       severity: "warning",
       code: "version-query-unreadable",
@@ -1268,7 +1487,202 @@ async function queryAvailableVersion(input) {
     }));
     return { status: "unknown", version: null, destination, diagnostics };
   }
-  return { status: "found", version: version2, destination, diagnostics };
+  return { status: "found", version: version3, 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) {
@@ -1349,14 +1763,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 +2295,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 +2575,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 +2734,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
@@ -2599,10 +3146,10 @@ function parsePins(raw, path, diagnostics) {
     if (typeof entry !== "object" || entry === null)
       continue;
     const provider = entry.provider;
-    const version2 = entry.version;
+    const version3 = entry.version;
     if (typeof provider !== "string" || provider === "")
       continue;
-    if (typeof version2 !== "string" || parseSemanticVersion(version2) === null) {
+    if (typeof version3 !== "string" || parseSemanticVersion(version3) === null) {
       diagnostics.push(diagnostic({
         severity: "warning",
         code: "pin-version-unparseable",
@@ -2611,7 +3158,7 @@ function parsePins(raw, path, diagnostics) {
       }));
       continue;
     }
-    pins.push({ provider, version: version2 });
+    pins.push({ provider, version: version3 });
   }
   return pins;
 }
@@ -2814,6 +3361,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 +3422,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 +3453,7 @@ async function executeTransaction(request) {
         status: "failed",
         snapshots: [],
         ownership: [],
+        packageInventory: null,
         diagnostics: [
           diagnostic({
             severity: "error",
@@ -2902,7 +3471,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 +3557,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();
@@ -4493,8 +5066,8 @@ async function detectVersion2(context) {
     };
   }
   const matched = VERSION_PATTERN.exec(outcome2.stdout);
-  const version2 = matched?.[1] ?? null;
-  if (version2 === null) {
+  const version3 = matched?.[1] ?? null;
+  if (version3 === null) {
     return {
       version: null,
       verdict: null,
@@ -4508,14 +5081,14 @@ async function detectVersion2(context) {
     };
   }
   return {
-    version: version2,
-    verdict: classifyVersion(version2, MANIFEST.testedVersions),
+    version: version3,
+    verdict: classifyVersion(version3, MANIFEST.testedVersions),
     evidence: [
       evidence({
         kind: "version-output",
         source: command.executable,
         path: outcome2.executablePath,
-        detail: `reported ${version2}`
+        detail: `reported ${version3}`
       })
     ]
   };
@@ -4523,7 +5096,7 @@ async function detectVersion2(context) {
 async function detect(context) {
   const evidenceItems = [];
   const warnings = [];
-  const { version: version2, verdict, evidence: versionEvidence } = await detectVersion2(context);
+  const { version: version3, verdict, evidence: versionEvidence } = await detectVersion2(context);
   evidenceItems.push(...versionEvidence);
   const configs = await Promise.all(MANIFEST.configFiles.map((declaration) => resolveConfig(declaration, context)));
   const present = configs.filter((config) => config.exists);
@@ -4546,7 +5119,7 @@ async function detect(context) {
       remediation: "Repair the JSON syntax, then run the command again"
     }));
   }
-  if (version2 === null && present.length > 0) {
+  if (version3 === null && present.length > 0) {
     warnings.push(diagnostic({
       severity: "warning",
       code: "harness-executable-missing",
@@ -4559,16 +5132,16 @@ async function detect(context) {
     warnings.push(diagnostic({
       severity: "warning",
       code: "harness-version-unknown-newer",
-      message: `Claude Code ${String(version2)} is newer than the versions whose configuration schema Token Harness has observed (up to ${String(MANIFEST.testedVersions.maximum)})`,
+      message: `Claude Code ${String(version3)} is newer than the versions whose configuration schema Token Harness has observed (up to ${String(MANIFEST.testedVersions.maximum)})`,
       remediation: "Check the release notes for hook-schema changes before applying a plan"
     }));
   }
-  const state = unparsed.length > 0 ? "broken" : configured.length > 0 && version2 !== null ? "configured" : version2 !== null || present.length > 0 ? "detected" : "absent";
+  const state = unparsed.length > 0 ? "broken" : configured.length > 0 && version3 !== null ? "configured" : version3 !== null || present.length > 0 ? "detected" : "absent";
   const primary = present.find((config) => config.declaration.primary) ?? present[0] ?? null;
   return {
     harnessId: CLAUDE,
     state,
-    version: version2,
+    version: version3,
     versionVerdict: verdict,
     configPath: primary?.path ?? null,
     declaredVerificationTier: MANIFEST.verificationTier,
@@ -4822,22 +5395,22 @@ async function detectVersion3(context) {
         })
       ]
     };
-  const version2 = VERSION_PATTERN2.exec(outcome2.stdout)?.[1] ?? null;
+  const version3 = VERSION_PATTERN2.exec(outcome2.stdout)?.[1] ?? null;
   return {
-    version: version2,
-    verdict: version2 === null ? null : classifyVersion(version2, MANIFEST2.testedVersions),
+    version: version3,
+    verdict: version3 === null ? null : classifyVersion(version3, MANIFEST2.testedVersions),
     evidence: [
       evidence({
         kind: "version-output",
         source: "codex",
         path: outcome2.executablePath,
-        detail: version2 === null ? "reported no recognisable semantic version" : `reported ${version2}`
+        detail: version3 === null ? "reported no recognisable semantic version" : `reported ${version3}`
       })
     ]
   };
 }
 async function detect2(context) {
-  const { version: version2, verdict, evidence: versionEvidence } = await detectVersion3(context);
+  const { version: version3, verdict, evidence: versionEvidence } = await detectVersion3(context);
   const configs = await Promise.all(MANIFEST2.configFiles.map((file) => resolveConfig2(file, context)));
   const present = configs.filter((config) => config.exists);
   const hooks = configs.find((config) => config.declaration.path.endsWith("hooks.json"));
@@ -4850,7 +5423,7 @@ async function detect2(context) {
       path: hooks.path,
       remediation: "Repair the JSON syntax, then run the command again"
     }));
-  if (version2 === null && present.length > 0)
+  if (version3 === null && present.length > 0)
     warnings.push(diagnostic({
       severity: "warning",
       code: "harness-executable-missing",
@@ -4862,15 +5435,15 @@ async function detect2(context) {
     warnings.push(diagnostic({
       severity: "warning",
       code: "harness-version-unknown-newer",
-      message: `Codex ${String(version2)} is newer than the observed hook schema`,
+      message: `Codex ${String(version3)} is newer than the observed hook schema`,
       remediation: "Check the release notes for hook-schema changes before applying a plan"
     }));
   const configured = (hooks?.configuredPoints.length ?? 0) > 0;
   const primary = configs.find((config) => config.declaration.primary && config.exists) ?? present[0] ?? null;
   return {
     harnessId: CODEX,
-    state: hooks?.exists && !hooks.parsed ? "broken" : configured && version2 !== null ? "configured" : version2 !== null || present.length > 0 ? "detected" : "absent",
-    version: version2,
+    state: hooks?.exists && !hooks.parsed ? "broken" : configured && version3 !== null ? "configured" : version3 !== null || present.length > 0 ? "detected" : "absent",
+    version: version3,
     versionVerdict: verdict,
     configPath: primary?.path ?? null,
     declaredVerificationTier: MANIFEST2.verificationTier,
@@ -4987,37 +5560,285 @@ async function verify2(context) {
 }
 var codexAdapter = { manifest: MANIFEST2, detect: detect2, inspect: inspect2, verify: verify2 };
 
-// packages/adapters/dist/src/harnesses/opencode.js
-var OPENCODE = harnessId("opencode");
+// packages/adapters/dist/src/harnesses/hermes.js
+var HERMES = harnessId("hermes");
 var VERSION_PATTERN3 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
+var PLUGIN = "harnesstrim";
 var MANIFEST3 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
-  id: OPENCODE,
-  displayName: "OpenCode",
-  homepage: "https://opencode.ai",
-  /**
-   * The version actually observed, not a round number.
-   *
-   * This read `1.0.0`–`1.0.0`, and the OpenCode on the machine this was reviewed against is
-   * `1.18.9` — so every real user got `unknown-newer`, which `doctor` counts as a problem, and
-   * every real machine exited 3. RFC 0006 §Exit codes forbids exactly that: "A supported
-   * configuration must be able to exit 0. A declared limitation is not a problem, and reporting
+  id: HERMES,
+  displayName: "Hermes Agent",
+  homepage: "https://hermes-agent.nousresearch.com/docs/",
+  testedVersions: { minimum: "0.1.0", maximum: "0.1.0" },
+  verificationTier: "config-only",
+  versionCommand: { executable: "hermes", args: ["--version"] },
+  interceptionPoints: [{ scopeId: "transform-tool-result", eventName: "transform_tool_result" }],
+  configFiles: [
+    {
+      path: ".hermes/plugins/harnesstrim/plugin.yaml",
+      scope: "user",
+      parser: "markers",
+      primary: true
+    },
+    {
+      path: ".hermes/plugins/harnesstrim/config.json",
+      scope: "user",
+      parser: "json",
+      primary: false
+    }
+  ],
+  toolFamilies: [
+    { id: "tool.result", platforms: ["windows", "macos", "linux"], executesShellCommands: false }
+  ],
+  requiresEnablement: true,
+  enablementNote: "The plugin must be enabled with `hermes plugins enable harnesstrim`.",
+  receiptFamily: "provider-telemetry"
+};
+async function resolveConfig3(declaration, context) {
+  const path = resolveConfigPath(declaration, context);
+  const stat3 = await context.fs.stat(path);
+  if (stat3 === null || stat3.kind !== "file") {
+    return {
+      declaration,
+      path,
+      exists: false,
+      parsed: false,
+      configuredPoints: [],
+      matchers: [],
+      commands: []
+    };
+  }
+  const text = new TextDecoder().decode(await context.fs.readFile(path));
+  const parsed = declaration.parser === "json" ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : text;
+  const valid = parsed !== null;
+  return {
+    declaration,
+    path,
+    exists: true,
+    parsed: valid,
+    configuredPoints: valid && declaration.path.endsWith("plugin.yaml") ? ["transform-tool-result"] : [],
+    matchers: valid && declaration.path.endsWith("plugin.yaml") ? ["tool.result"] : [],
+    commands: valid && declaration.path.endsWith("plugin.yaml") ? ["hermes plugins enable harnesstrim"] : []
+  };
+}
+async function version2(context) {
+  const result = await context.runner.run({
+    executable: "hermes",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (result.failure !== null)
+    return {
+      value: null,
+      verdict: null,
+      evidence: [
+        evidence({
+          kind: "absence",
+          source: "hermes",
+          detail: `not runnable: ${result.failure.reason}`
+        })
+      ]
+    };
+  const value = VERSION_PATTERN3.exec(result.stdout)?.[1] ?? null;
+  return {
+    value,
+    verdict: value === null ? null : classifyVersion(value, MANIFEST3.testedVersions),
+    evidence: [
+      evidence({
+        kind: "version-output",
+        source: "hermes",
+        path: result.executablePath,
+        detail: value ? `reported ${value}` : "reported no recognisable version"
+      })
+    ]
+  };
+}
+async function enabled(context) {
+  const result = await context.runner.run({
+    executable: "hermes",
+    args: ["plugins", "list"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (result.failure !== null || result.exitCode !== 0)
+    return null;
+  const line = result.stdout.split("\n").find((entry) => entry.toLowerCase().includes(PLUGIN));
+  return line === void 0 ? false : /enabled/i.test(line);
+}
+async function detect3(context) {
+  const observed = await version2(context);
+  const configs = await Promise.all(MANIFEST3.configFiles.map((file) => resolveConfig3(file, context)));
+  const plugin = configs.find((file) => file.declaration.path.endsWith("plugin.yaml"));
+  const isEnabled = await enabled(context);
+  const warnings = [];
+  if (observed.verdict === "unknown-newer")
+    warnings.push(diagnostic({
+      severity: "warning",
+      code: "harness-version-unknown-newer",
+      message: `Hermes ${observed.value} is newer than the observed plugin contract`,
+      remediation: "Review the transform_tool_result plugin contract before applying changes"
+    }));
+  if (plugin?.exists && isEnabled === false)
+    warnings.push(diagnostic({
+      severity: "warning",
+      code: "plugin-disabled",
+      message: "HarnessTrim is installed in Hermes but is not enabled",
+      path: plugin.path,
+      remediation: "Run `hermes plugins enable harnesstrim`"
+    }));
+  const present = plugin?.exists === true;
+  return {
+    harnessId: HERMES,
+    state: present && isEnabled === true && observed.value !== null ? "configured" : present || observed.value !== null ? "detected" : "absent",
+    version: observed.value,
+    versionVerdict: observed.verdict,
+    configPath: plugin?.path ?? null,
+    declaredVerificationTier: MANIFEST3.verificationTier,
+    evidence: [
+      ...observed.evidence,
+      ...plugin ? [
+        evidence({
+          kind: "config-entry",
+          source: "Hermes plugin directory",
+          path: plugin.path,
+          detail: plugin.exists ? "HarnessTrim plugin manifest present" : "plugin manifest absent"
+        })
+      ] : []
+    ],
+    warnings
+  };
+}
+async function inspect3(context) {
+  const configs = await Promise.all(MANIFEST3.configFiles.map((file) => resolveConfig3(file, context)));
+  return {
+    harnessId: HERMES,
+    configs,
+    activeToolFamilies: familiesOnThisPlatform(MANIFEST3, context.facts),
+    uncoveredToolFamilies: [],
+    enabled: await enabled(context),
+    diagnostics: [],
+    summaries: configs.filter((config) => config.configuredPoints.length > 0).map((config) => ({
+      harnessId: HERMES,
+      configPath: config.path,
+      scope: config.declaration.scope,
+      interceptionPoints: config.configuredPoints,
+      matchers: config.matchers,
+      commands: config.commands
+    }))
+  };
+}
+async function verify3(context) {
+  const detection = await detect3(context);
+  const inspection = await inspect3(context);
+  const plugin = inspection.configs.some((config) => config.configuredPoints.length > 0);
+  const checks = [
+    {
+      id: "executable-resolves",
+      status: detection.version === null ? "fail" : "pass",
+      summary: detection.version === null ? "hermes could not be run" : `Hermes ${detection.version}`,
+      achievedTier: detection.version === null ? null : "presence",
+      evidence: detection.evidence.filter((item) => item.kind === "version-output"),
+      remediation: detection.version === null ? "Install Hermes or add it to PATH" : null
+    },
+    {
+      id: "plugin-installed",
+      status: plugin ? "pass" : "fail",
+      summary: plugin ? "HarnessTrim plugin manifest is installed" : "HarnessTrim plugin manifest is missing",
+      achievedTier: plugin ? "config-only" : null,
+      evidence: [],
+      remediation: plugin ? null : "Run `harnesstrim install hermes --apply`"
+    },
+    {
+      id: "plugin-enabled",
+      status: inspection.enabled === true ? "pass" : inspection.enabled === false ? "fail" : "not-exercised",
+      summary: inspection.enabled === true ? "HarnessTrim is enabled" : inspection.enabled === false ? "HarnessTrim is installed but disabled" : "Hermes plugin state could not be read",
+      achievedTier: inspection.enabled === true ? "config-only" : null,
+      evidence: [],
+      remediation: inspection.enabled === false ? "Run `hermes plugins enable harnesstrim`" : null
+    },
+    {
+      id: "canary-intercepted",
+      status: "not-exercised",
+      summary: "Hermes exposes no independent receipt; HarnessTrim telemetry is verified by the provider adapter",
+      achievedTier: null,
+      evidence: [],
+      remediation: null
+    }
+  ];
+  return {
+    harnessId: HERMES,
+    declaredTier: MANIFEST3.verificationTier,
+    achievedTier: checks.some((check) => check.achievedTier === "config-only") ? "config-only" : checks.some((check) => check.achievedTier === "presence") ? "presence" : null,
+    checks
+  };
+}
+var hermesAdapter = { manifest: MANIFEST3, detect: detect3, inspect: inspect3, verify: verify3 };
+
+// packages/adapters/dist/src/harnesses/opencode.js
+var OPENCODE = harnessId("opencode");
+var VERSION_PATTERN4 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
+var MANIFEST4 = {
+  schemaVersion: MANIFEST_SCHEMA_VERSION,
+  id: OPENCODE,
+  displayName: "OpenCode",
+  homepage: "https://opencode.ai",
+  /**
+   * The version actually observed, not a round number.
+   *
+   * This read `1.0.0`–`1.0.0`, and the OpenCode on the machine this was reviewed against is
+   * `1.18.9` — so every real user got `unknown-newer`, which `doctor` counts as a problem, and
+   * every real machine exited 3. RFC 0006 §Exit codes forbids exactly that: "A supported
+   * 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 +5855,38 @@ function pluginEntries(document2) {
     return [];
   return document2["plugin"].filter((item) => typeof item === "string");
 }
-async function resolveConfig3(declaration, context) {
+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 resolveConfig4(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 +5918,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
@@ -5091,23 +5945,23 @@ async function detectVersion4(context) {
         })
       ]
     };
-  const version2 = VERSION_PATTERN3.exec(outcome2.stdout)?.[1] ?? null;
+  const version3 = VERSION_PATTERN4.exec(outcome2.stdout)?.[1] ?? null;
   return {
-    version: version2,
-    verdict: version2 === null ? null : classifyVersion(version2, MANIFEST3.testedVersions),
+    version: version3,
+    verdict: version3 === null ? null : classifyVersion(version3, MANIFEST4.testedVersions),
     evidence: [
       evidence({
         kind: "version-output",
         source: "opencode",
         path: outcome2.executablePath,
-        detail: version2 === null ? "reported no recognisable semantic version" : `reported ${version2}`
+        detail: version3 === null ? "reported no recognisable semantic version" : `reported ${version3}`
       })
     ]
   };
 }
-async function detect3(context) {
-  const { version: version2, verdict, evidence: versionEvidence } = await detectVersion4(context);
-  const configs = await Promise.all(MANIFEST3.configFiles.map((file) => resolveConfig3(file, context)));
+async function detect4(context) {
+  const { version: version3, verdict, evidence: versionEvidence } = await detectVersion4(context);
+  const configs = await Promise.all(MANIFEST4.configFiles.map((file) => resolveConfig4(file, context)));
   const present = configs.filter((config) => config.exists);
   const configured = present.filter((config) => config.configuredPoints.length > 0);
   const warnings = [];
@@ -5123,17 +5977,17 @@ async function detect3(context) {
     warnings.push(diagnostic({
       severity: "warning",
       code: "harness-version-unknown-newer",
-      message: `OpenCode ${String(version2)} is newer than the observed configuration schema`,
+      message: `OpenCode ${String(version3)} is newer than the observed configuration schema`,
       remediation: "Check the release notes for plugin-schema changes before applying a plan"
     }));
   const primary = present.find((config) => config.declaration.primary) ?? present[0] ?? null;
   return {
     harnessId: OPENCODE,
-    state: present.some((config) => !config.parsed) ? "broken" : configured.length > 0 && version2 !== null ? "configured" : version2 !== null || present.length > 0 ? "detected" : "absent",
-    version: version2,
+    state: present.some((config) => !config.parsed) ? "broken" : configured.length > 0 && version3 !== null ? "configured" : version3 !== null || present.length > 0 ? "detected" : "absent",
+    version: version3,
     versionVerdict: verdict,
     configPath: primary?.path ?? null,
-    declaredVerificationTier: MANIFEST3.verificationTier,
+    declaredVerificationTier: MANIFEST4.verificationTier,
     evidence: [
       ...versionEvidence,
       ...present.map((config) => evidence({
@@ -5146,18 +6000,224 @@ async function detect3(context) {
     warnings
   };
 }
-async function inspect3(context) {
-  const configs = await Promise.all(MANIFEST3.configFiles.map((file) => resolveConfig3(file, context)));
-  const activeToolFamilies = familiesOnThisPlatform(MANIFEST3, context.facts);
+async function inspect4(context) {
+  const configs = await Promise.all(MANIFEST4.configFiles.map((file) => resolveConfig4(file, context)));
+  const activeToolFamilies = familiesOnThisPlatform(MANIFEST4, context.facts);
+  return {
+    harnessId: OPENCODE,
+    configs,
+    activeToolFamilies,
+    uncoveredToolFamilies: [],
+    enabled: null,
+    diagnostics: [],
+    summaries: configs.filter((config) => config.configuredPoints.length > 0).map((config) => ({
+      harnessId: OPENCODE,
+      configPath: config.path,
+      scope: config.declaration.scope,
+      interceptionPoints: config.configuredPoints,
+      matchers: config.matchers,
+      commands: config.commands
+    }))
+  };
+}
+async function verify4(context) {
+  const detection = await detect4(context);
+  const inspection = await inspect4(context);
+  const configured = inspection.configs.some((config) => config.configuredPoints.length > 0);
+  const readable = inspection.configs.filter((config) => config.exists).every((config) => config.parsed);
+  const checks = [
+    {
+      id: "executable-resolves",
+      status: detection.version === null ? "fail" : "pass",
+      summary: detection.version === null ? "opencode could not be run" : `opencode ${detection.version} resolves`,
+      achievedTier: detection.version === null ? null : "presence",
+      evidence: detection.evidence.filter((item) => item.kind === "version-output"),
+      remediation: detection.version === null ? "Install OpenCode or make it available on PATH" : null
+    },
+    {
+      id: "config-readable",
+      status: !readable ? "fail" : configured ? "pass" : "not-exercised",
+      summary: !readable ? "OpenCode configuration is not valid JSONC" : configured ? "OpenCode plugin configuration is readable" : "No OpenCode plugin configuration is present",
+      achievedTier: configured && readable ? "config-only" : null,
+      evidence: [],
+      remediation: !readable ? "Repair the JSONC syntax, then run verify again" : null
+    },
+    {
+      id: "plugin-registered",
+      status: configured ? "pass" : "not-exercised",
+      summary: configured ? "A plugin entry is registered for tool.execute.after" : "No plugin entry is registered",
+      achievedTier: configured ? "config-only" : null,
+      evidence: [],
+      remediation: configured ? null : "Configure the OpenCode plugin, or adopt an existing configuration"
+    },
+    {
+      id: "canary-intercepted",
+      status: "not-exercised",
+      summary: "No observable receipt exists for an adopted generated plugin wrapper",
+      achievedTier: null,
+      evidence: [],
+      remediation: null
+    }
+  ];
+  return {
+    harnessId: OPENCODE,
+    declaredTier: MANIFEST4.verificationTier,
+    achievedTier: detection.version !== null && configured && readable ? "config-only" : detection.version !== null ? "presence" : null,
+    checks
+  };
+}
+var opencodeAdapter = { manifest: MANIFEST4, detect: detect4, inspect: inspect4, verify: verify4 };
+
+// packages/adapters/dist/src/harnesses/pi.js
+var PI = harnessId("pi");
+var VERSION_PATTERN5 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
+var MANIFEST5 = {
+  schemaVersion: MANIFEST_SCHEMA_VERSION,
+  id: PI,
+  displayName: "Pi",
+  // The npm package declares no `homepage`; the repository it ships is the documented home.
+  homepage: "https://github.com/earendil-works/pi",
+  // Only the version actually observed — PLAN §15 item 31, "tested range of exactly the observed
+  // version". `pi --version` on the machine this was written against printed `0.83.0`.
+  testedVersions: { minimum: "0.83.0", maximum: "0.83.0" },
+  // RFC 0007: the extension emits no receipt of its own, so nothing above `config-only` is
+  // provable. The configuration is the extension module sitting in an auto-loaded directory.
+  verificationTier: "config-only",
+  versionCommand: { executable: "pi", args: ["--version"] },
+  interceptionPoints: [{ scopeId: "tool-result", eventName: "tool_result" }],
+  // `markers` because there is nothing to parse: Pi auto-loads any module in these directories,
+  // and the presence of the HarnessTrim extension file is the whole configuration.
+  configFiles: [
+    {
+      path: ".pi/agent/extensions/harnesstrim/index.ts",
+      scope: "user",
+      parser: "markers",
+      primary: true
+    },
+    {
+      path: ".pi/extensions/harnesstrim/harnesstrim.ts",
+      scope: "project",
+      parser: "markers",
+      primary: false
+    }
+  ],
+  // The extension intercepts `tool_result` and reduces text chunks — a content seam, never a
+  // shell. Mirrors the OpenCode plugin API claim.
+  toolFamilies: [
+    { id: "tool.result", platforms: ["windows", "macos", "linux"], executesShellCommands: false }
+  ],
+  // There is no separate enable state: the module being present in the directory is the load
+  // decision, so the adapter reads presence and nothing else.
+  requiresEnablement: false,
+  enablementNote: null,
+  receiptFamily: "none"
+};
+async function resolveConfig5(declaration, context) {
+  const path = resolveConfigPath(declaration, context);
+  const stat3 = await context.fs.stat(path);
+  if (stat3 === null || stat3.kind !== "file") {
+    return {
+      declaration,
+      path,
+      exists: false,
+      parsed: false,
+      configuredPoints: [],
+      matchers: [],
+      commands: []
+    };
+  }
+  const text = new TextDecoder().decode(await context.fs.readFile(path));
+  const isHarnesstrim = /harnesstrim/i.test(text);
+  return {
+    declaration,
+    path,
+    exists: true,
+    parsed: isHarnesstrim,
+    configuredPoints: isHarnesstrim ? ["tool-result"] : [],
+    matchers: isHarnesstrim ? ["tool.result"] : [],
+    // There is no enable command: Pi loads the module from the directory directly.
+    commands: []
+  };
+}
+async function detectVersion5(context) {
+  const result = await context.runner.run({
+    executable: "pi",
+    args: ["--version"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (result.failure !== null)
+    return {
+      value: null,
+      verdict: null,
+      evidence: [
+        evidence({
+          kind: "absence",
+          source: "pi",
+          detail: `not runnable: ${result.failure.reason}`
+        })
+      ]
+    };
+  const value = VERSION_PATTERN5.exec(result.stdout)?.[1] ?? null;
+  return {
+    value,
+    verdict: value === null ? null : classifyVersion(value, MANIFEST5.testedVersions),
+    evidence: [
+      evidence({
+        kind: "version-output",
+        source: "pi",
+        path: result.executablePath,
+        detail: value ? `reported ${value}` : "reported no recognisable version"
+      })
+    ]
+  };
+}
+async function detect5(context) {
+  const observed = await detectVersion5(context);
+  const configs = await Promise.all(MANIFEST5.configFiles.map((file) => resolveConfig5(file, context)));
+  const module = configs.find((file) => file.parsed);
+  const present = module !== void 0;
+  const warnings = [];
+  if (observed.verdict === "unknown-newer")
+    warnings.push(diagnostic({
+      severity: "warning",
+      code: "harness-version-unknown-newer",
+      message: `Pi ${observed.value} is newer than the observed extension contract`,
+      remediation: "Review the tool_result extension contract before applying changes"
+    }));
+  return {
+    harnessId: PI,
+    state: present && observed.value !== null ? "configured" : present || observed.value !== null ? "detected" : "absent",
+    version: observed.value,
+    versionVerdict: observed.verdict,
+    configPath: module?.path ?? null,
+    declaredVerificationTier: MANIFEST5.verificationTier,
+    evidence: [
+      ...observed.evidence,
+      ...module ? [
+        evidence({
+          kind: "config-entry",
+          source: "HarnessTrim Pi extension",
+          path: module.path,
+          detail: "extension module present in an auto-loaded directory"
+        })
+      ] : []
+    ],
+    warnings
+  };
+}
+async function inspect5(context) {
+  const configs = await Promise.all(MANIFEST5.configFiles.map((file) => resolveConfig5(file, context)));
   return {
-    harnessId: OPENCODE,
+    harnessId: PI,
     configs,
-    activeToolFamilies,
+    activeToolFamilies: familiesOnThisPlatform(MANIFEST5, context.facts),
     uncoveredToolFamilies: [],
+    // No separate enablement exists, so nothing is reported as enabled or disabled.
     enabled: null,
     diagnostics: [],
     summaries: configs.filter((config) => config.configuredPoints.length > 0).map((config) => ({
-      harnessId: OPENCODE,
+      harnessId: PI,
       configPath: config.path,
       scope: config.declaration.scope,
       interceptionPoints: config.configuredPoints,
@@ -5166,56 +6226,61 @@ async function inspect3(context) {
     }))
   };
 }
-async function verify3(context) {
-  const detection = await detect3(context);
-  const inspection = await inspect3(context);
-  const configured = inspection.configs.some((config) => config.configuredPoints.length > 0);
-  const readable = inspection.configs.filter((config) => config.exists).every((config) => config.parsed);
+async function verify5(context) {
+  const detection = await detect5(context);
+  const inspection = await inspect5(context);
+  const module = inspection.configs.some((config) => config.configuredPoints.length > 0);
   const checks = [
     {
       id: "executable-resolves",
       status: detection.version === null ? "fail" : "pass",
-      summary: detection.version === null ? "opencode could not be run" : `opencode ${detection.version} resolves`,
+      summary: detection.version === null ? "pi could not be run" : `Pi ${detection.version}`,
       achievedTier: detection.version === null ? null : "presence",
       evidence: detection.evidence.filter((item) => item.kind === "version-output"),
-      remediation: detection.version === null ? "Install OpenCode or make it available on PATH" : null
+      remediation: detection.version === null ? "Install Pi or add it to PATH" : null
     },
     {
-      id: "config-readable",
-      status: !readable ? "fail" : configured ? "pass" : "not-exercised",
-      summary: !readable ? "OpenCode configuration is not valid JSONC" : configured ? "OpenCode plugin configuration is readable" : "No OpenCode plugin configuration is present",
-      achievedTier: configured && readable ? "config-only" : null,
+      id: "module-installed",
+      status: module ? "pass" : "fail",
+      summary: module ? "HarnessTrim extension module is installed" : "No HarnessTrim extension module was found in the Pi extension directories",
+      achievedTier: module ? "config-only" : null,
       evidence: [],
-      remediation: !readable ? "Repair the JSONC syntax, then run verify again" : null
+      remediation: module ? null : "Run `harnesstrim install pi --apply`"
     },
     {
-      id: "plugin-registered",
-      status: configured ? "pass" : "not-exercised",
-      summary: configured ? "A plugin entry is registered for tool.execute.after" : "No plugin entry is registered",
-      achievedTier: configured ? "config-only" : null,
+      id: "mode-unreadable",
+      status: "info",
+      summary: "The effective reduction mode (HARNESSTRIM_MODE) defaults to dryrun and is not observable from the extension alone",
+      achievedTier: null,
       evidence: [],
-      remediation: configured ? null : "Configure the OpenCode plugin, or adopt an existing configuration"
+      remediation: null
     },
     {
       id: "canary-intercepted",
       status: "not-exercised",
-      summary: "No observable receipt exists for an adopted generated plugin wrapper",
+      summary: "Pi exposes no independent receipt; HarnessTrim telemetry is verified by the provider adapter",
       achievedTier: null,
       evidence: [],
       remediation: null
     }
   ];
   return {
-    harnessId: OPENCODE,
-    declaredTier: MANIFEST3.verificationTier,
-    achievedTier: detection.version !== null && configured && readable ? "config-only" : detection.version !== null ? "presence" : null,
+    harnessId: PI,
+    declaredTier: MANIFEST5.verificationTier,
+    achievedTier: checks.some((check) => check.achievedTier === "config-only") ? "config-only" : checks.some((check) => check.achievedTier === "presence") ? "presence" : null,
     checks
   };
 }
-var opencodeAdapter = { manifest: MANIFEST3, detect: detect3, inspect: inspect3, verify: verify3 };
+var piAdapter = { manifest: MANIFEST5, detect: detect5, inspect: inspect5, verify: verify5 };
 
 // packages/adapters/dist/src/harnesses/index.js
-var HARNESS_ADAPTERS = [claudeAdapter, codexAdapter, opencodeAdapter];
+var HARNESS_ADAPTERS = [
+  claudeAdapter,
+  codexAdapter,
+  hermesAdapter,
+  opencodeAdapter,
+  piAdapter
+];
 function listHarnessAdapters() {
   return HARNESS_ADAPTERS;
 }
@@ -5223,8 +6288,11 @@ function listHarnessAdapters() {
 // packages/adapters/dist/src/providers/harnesstrim.js
 var HARNESSTRIM2 = providerId("harnesstrim");
 var CLAUDE2 = harnessId("claude");
+var HERMES2 = harnessId("hermes");
 var CODEX2 = harnessId("codex");
-var CLAUDE_ARTIFACT_DIGESTS = {
+var PI2 = harnessId("pi");
+var SKILLS_UPSTREAM = "0.0.7";
+var SKILL_ARTIFACT_DIGESTS = {
   "compact-handoff/SKILL.md": "sha256:0efbf35581c559359e755b204778b64a289dab4d20dadc1cba3d5b5c995b5f01",
   "debug-log-slim/SKILL.md": "sha256:17f5ccc34d29d7aba083444e0e4d87fd3d49916ebcb4e6544caf8c89f13f0045",
   "delegate-bulk/SKILL.md": "sha256:3753de2ad18271c24832e4cda63115d353620515d5d80f40e93bc07d2a7257d7",
@@ -5233,9 +6301,18 @@ var CLAUDE_ARTIFACT_DIGESTS = {
   "review-delta/SKILL.md": "sha256:4dfbf9d6ec08dff27b4759726536b43928370e288706fa01f5b498648e741388",
   "scaffold-fast/SKILL.md": "sha256:1a18d52c4d335fbd3f74e2559bc20d6346193a40eef7b85149f51f44f697d182"
 };
+var SKILL_ARTIFACTS = Object.keys(SKILL_ARTIFACT_DIGESTS);
 var OPENCODE2 = harnessId("opencode");
+var MODE_CARRYING_HARNESSES = /* @__PURE__ */ new Set([
+  OPENCODE2,
+  HERMES2,
+  harnessId("pi"),
+  harnessId("omp")
+]);
 var HOOK_COMMAND_PATTERN = /(^|[\\/\s"'])harnesstrim(\.cmd|\.exe)?([\s"']|$)/i;
-var MANIFEST4 = {
+var PLUGIN_MODULE_PATTERN2 = /(^|[\\/])harnesstrim\.(ts|js|mjs|cjs|mts|cts)$/i;
+var PI_EXTENSION_PATTERN = /(^|[\\/])\.pi[\\/](agent[\\/])?extensions[\\/]harnesstrim[\\/]/i;
+var MANIFEST6 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
   id: HARNESSTRIM2,
   displayName: "HarnessTrim",
@@ -5311,36 +6388,264 @@ 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", ".hermes/harnesstrim-metrics.jsonl"]
   },
-  delegatedInstallReview: {
-    upstreamVersion: "0.0.7",
-    reviewedWriteSet: [
-      ...Object.keys(CLAUDE_ARTIFACT_DIGESTS).map((path) => `.claude/skills/${path}`)
-    ],
-    containmentBoundary: [".claude", "CLAUDE.md"],
-    upstreamUninstallAvailable: true
+  /**
+   * One review per harness — PLAN §15 item 46b.
+   *
+   * Codex was observed at `0.1.0`: `harnesstrim install codex <dir> --apply --no-instructions`
+   * writes the same seven skill artifacts as the Claude invocation, byte for byte — the digests
+   * below are shared because the files are the same files — under `.codex/skills/` instead, and
+   * skips `AGENTS.md` exactly as the Claude one skips `CLAUDE.md`. What differs is the boundary and
+   * the protected paths, which is precisely why one review could not describe both.
+   *
+   * OpenCode is absent on purpose. Its installer writes `.opencode/plugin/harnesstrim.ts` and
+   * `.opencode/package.json` *and runs an npm install*, so the containment boundary would hold a
+   * `node_modules` tree: a snapshot question, not another entry in this map.
+   */
+  delegatedInstallReviews: {
+    claude: {
+      upstreamVersion: SKILLS_UPSTREAM,
+      reviewedWriteSet: SKILL_ARTIFACTS.map((path) => `.claude/skills/${path}`),
+      containmentBoundary: [".claude", "CLAUDE.md"],
+      upstreamUninstallAvailable: true
+    },
+    codex: {
+      upstreamVersion: SKILLS_UPSTREAM,
+      reviewedWriteSet: SKILL_ARTIFACTS.map((path) => `.codex/skills/${path}`),
+      containmentBoundary: [".codex", "AGENTS.md"],
+      upstreamUninstallAvailable: true
+    }
+  }
+};
+var SKILLS_INSTALL = {
+  claude: {
+    directory: ".claude",
+    instructions: "CLAUDE.md",
+    hook: "settings.json",
+    args: ["--no-hook", "--no-instructions"]
+  },
+  codex: {
+    directory: ".codex",
+    instructions: "AGENTS.md",
+    hook: "hooks.json",
+    args: ["--no-instructions"]
   }
 };
 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 version3 = record["version"];
+  const harnesses = record["harnesses"];
+  if (typeof version3 !== "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: version3, 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 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));
+  }).map((harness) => harnessId(harness));
+}
+function writeSetStillReviewed(capabilities, harness) {
+  const review = MANIFEST6.delegatedInstallReviews?.[harness];
+  if (review === void 0 || 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`));
+      }
+    }
+  }
+  for (const [harness, review] of Object.entries(manifest.delegatedInstallReviews ?? {})) {
+    const observed = capabilities.harnesses[harness];
+    if (observed === void 0)
+      continue;
+    const declared = observed.writeSet.map(writeSetPath);
+    for (const reviewed of review.reviewedWriteSet) {
+      if (declared.some((entry) => coveredBy(reviewed, entry)))
+        continue;
+      warnings.push(driftWarning(`the reviewed ${harness} 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 ${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"));
+    }
+  }
+  return warnings;
 }
 function harnessesWiredToHarnessTrim(configs) {
   const wired = /* @__PURE__ */ new Set();
   for (const config of configs) {
-    if (config.commands.some((command) => identifiesCommand(command)))
+    const hermesPlugin = config.harnessId === HERMES2 && (config.configPath.toLowerCase().includes(".hermes/plugins/harnesstrim") || config.commands.some((command) => /hermes plugins enable harnesstrim/i.test(command)));
+    const piExtension = config.harnessId === PI2 && PI_EXTENSION_PATTERN.test(config.configPath);
+    if (piExtension || hermesPlugin || config.commands.some((command) => identifiesCommand(command))) {
       wired.add(config.harnessId);
+    }
   }
   return [...wired];
 }
-var VERSION_PATTERN4 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
+var VERSION_PATTERN6 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
 async function probeExecutable(context) {
   const asked = await context.runner.run({
     executable: "harnesstrim",
@@ -5363,17 +6668,17 @@ async function probeExecutable(context) {
     };
   }
   if (asked.exitCode === 0) {
-    const version2 = VERSION_PATTERN4.exec(asked.stdout)?.[1] ?? null;
+    const version3 = VERSION_PATTERN6.exec(asked.stdout)?.[1] ?? null;
     return {
       installed: true,
-      version: version2,
+      version: version3,
       path: asked.executablePath,
       evidence: [
         evidence({
           kind: "version-output",
           source: "harnesstrim --version",
           path: asked.executablePath,
-          detail: version2 === null ? "reported no recognisable version" : `reported ${version2}`
+          detail: version3 === null ? "reported no recognisable version" : `reported ${version3}`
         })
       ]
     };
@@ -5418,11 +6723,15 @@ function metricsLocations(context) {
     context.fs.join(context.paths.home, ".hermes", "harnesstrim-metrics.jsonl")
   ];
 }
-async function detect4(context) {
+async function detect6(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(MANIFEST6, observed.capabilities));
+  }
   for (const harness of configured) {
     evidenceItems.push(evidence({
       kind: "config-entry",
@@ -5452,7 +6761,7 @@ async function detect4(context) {
     // cannot answer.
     versionVerdict: probe.version === null ? null : classifyVersion(probe.version, TESTED_VERSIONS),
     configuredHarnesses: configured,
-    unmanagedHarnessesConfigured: configured.filter((harness) => !MANIFEST4.harnesses.some((entry) => entry.harness === harness)),
+    unmanagedHarnessesConfigured: configured.filter((harness) => !MANIFEST6.harnesses.some((entry) => entry.harness === harness)),
     // RFC 0002 §Providers may exceed the managed surface: HarnessTrim ships adapters for Hermes and
     // Pi as well, which Token Harness does not manage, so a wired one is reported and left alone.
     supportsUnmanagedHarnesses: true,
@@ -5460,6 +6769,9 @@ 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, per harness. Decided by the build in front of us and by which harnesses
+    // carry a reviewed write set: those are the two things that make the assignment producible.
+    assignableHarnesses: assignableOn(observed?.capabilities ?? null),
     evidence: evidenceItems,
     warnings
   };
@@ -5481,6 +6793,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 +6806,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 +6822,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.
@@ -5518,31 +6843,40 @@ function toEvent(event, sourceId, ordinal, line, context) {
       pipelineId: null,
       pipelineOrder: null,
       toolFamily: event.tool === "" ? null : event.tool,
-      capability: event.harness === OPENCODE2 ? "tool.output.reduce" : "shell.output.reduce"
+      capability: event.harness === OPENCODE2 || event.harness === HERMES2 || event.harness === PI2 ? "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) {
+async function verify6(context) {
   const checks = [];
   const diagnostics = [];
   const probe = await probeExecutable(context);
@@ -5590,7 +6924,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 +6960,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 +7012,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,91 +7067,128 @@ 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,
     diagnostics
   };
 }
-async function plan(context, request) {
-  const claudeDirectory = context.fs.join(context.projectRoot, ".claude");
-  const skillsDirectory = context.fs.join(claudeDirectory, "skills");
-  const expectedArtifacts = Object.entries(CLAUDE_ARTIFACT_DIGESTS).map(([path, digest]) => ({
-    path: context.fs.join(skillsDirectory, ...path.split("/")),
+function skillArtifacts(context, harness) {
+  const install = SKILLS_INSTALL[harness];
+  if (install === void 0)
+    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
   }));
-  if (!request.harnesses.some((harness) => harness.id === CLAUDE2)) {
+}
+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);
+  if (targets.length === 0) {
     return { providerId: HARNESSTRIM2, desiredState: request.desiredState, actions: [] };
   }
   if (request.desiredState === "absent") {
-    const actions = expectedArtifacts.map((artifact) => ({
+    const actions2 = targets.flatMap((harness) => skillArtifacts(context, harness).map((artifact) => ({
       kind: "remove-owned-change",
-      id: `harnesstrim-claude-skill-remove-${digestText(artifact.path).slice(7, 15)}`,
+      id: `harnesstrim-${harness}-skill-remove-${digestText(artifact.path).slice(7, 15)}`,
       riskClass: "reversible",
       requiresNetwork: false,
       requiresElevation: false,
       affectedPaths: [artifact.path],
       affectedProcesses: [],
-      preconditions: ["the HarnessTrim skill still matches the reviewed 0.0.7 artifact"],
+      preconditions: [
+        `the HarnessTrim skill still matches the reviewed ${SKILLS_UPSTREAM} artifact`
+      ],
       postconditions: ["the owned HarnessTrim skill is absent"],
       rollbackData: "file-snapshot",
-      explanation: `Remove the owned HarnessTrim Claude skill ${context.fs.basename(context.fs.dirname(artifact.path))}`,
+      explanation: `Remove the owned HarnessTrim ${harness} skill ${context.fs.basename(context.fs.dirname(artifact.path))}`,
       path: artifact.path,
-      reverses: `harnesstrim-claude-skills-${digestText(context.projectRoot).slice(7, 15)}`,
-      target: { kind: "owned-file", path: artifact.path, digest: artifact.digest, mode: null }
-    }));
-    return { providerId: HARNESSTRIM2, desiredState: "absent", actions };
+      reverses: `harnesstrim-${harness}-skills-${digestText(context.projectRoot).slice(7, 15)}`,
+      target: {
+        kind: "owned-file",
+        path: artifact.path,
+        digest: artifact.digest,
+        mode: null
+      }
+    })));
+    return { providerId: HARNESSTRIM2, desiredState: "absent", actions: actions2 };
   }
   const installed = await probeExecutable(context);
-  if (installed.version !== TESTED_UPSTREAM) {
+  if (!installed.installed) {
     return { providerId: HARNESSTRIM2, desiredState: "configured", actions: [] };
   }
-  const review = MANIFEST4.delegatedInstallReview;
-  if (review === null)
-    throw new Error("HarnessTrim delegated-install review is missing");
-  const action = {
-    kind: "delegated-provider-install",
-    id: `harnesstrim-claude-skills-${digestText(context.projectRoot).slice(7, 15)}`,
-    riskClass: "delegated",
-    requiresNetwork: false,
-    requiresElevation: false,
-    affectedPaths: expectedArtifacts.map((artifact) => artifact.path),
-    affectedProcesses: ["harnesstrim"],
-    preconditions: [
-      "harnesstrim 0.0.7 is installed and on PATH",
-      "the reviewed installer writes only the declared Claude skill artifacts"
-    ],
-    postconditions: [
-      "HarnessTrim Claude skills match the reviewed 0.0.7 artifacts",
-      "no HarnessTrim hook or reduce-pipe instruction was added"
-    ],
-    rollbackData: "directory-snapshot",
-    explanation: "Install HarnessTrim Claude skills without a hook or reduce-pipe instruction",
-    executable: "harnesstrim",
-    args: ["install", "claude", context.projectRoot, "--apply", "--no-hook", "--no-instructions"],
-    containmentBoundary: review.containmentBoundary.map((path) => context.fs.join(context.projectRoot, path)),
-    expectedArtifacts,
-    protectedPaths: [
-      context.fs.join(claudeDirectory, "settings.json"),
-      context.fs.join(context.projectRoot, "CLAUDE.md")
-    ],
-    rollbackStrategy: "restore-snapshot",
-    snapshotSizeCapBytes: 1048576,
-    upstreamUninstallAvailable: review.upstreamUninstallAvailable
-  };
-  return { providerId: HARNESSTRIM2, desiredState: "configured", actions: [action] };
+  const observed = await probeCapabilities(context);
+  const actions = [];
+  for (const harness of targets) {
+    const review = reviews[harness];
+    const install = SKILLS_INSTALL[harness];
+    if (review === void 0 || install === void 0)
+      continue;
+    const reviewed = observed.capabilities === null ? installed.version === review.upstreamVersion : writeSetStillReviewed(observed.capabilities, harnessId(harness));
+    if (!reviewed)
+      continue;
+    const expectedArtifacts = skillArtifacts(context, harness);
+    actions.push({
+      kind: "delegated-provider-install",
+      id: `harnesstrim-${harness}-skills-${digestText(context.projectRoot).slice(7, 15)}`,
+      riskClass: "delegated",
+      requiresNetwork: false,
+      requiresElevation: false,
+      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`
+      ],
+      postconditions: [
+        `HarnessTrim ${harness} skills match the reviewed ${review.upstreamVersion} artifacts`,
+        "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)),
+      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)
+      ],
+      rollbackStrategy: "restore-snapshot",
+      snapshotSizeCapBytes: 1048576,
+      upstreamUninstallAvailable: review.upstreamUninstallAvailable
+    });
+  }
+  return { providerId: HARNESSTRIM2, desiredState: "configured", actions };
 }
 var harnesstrimAdapter = {
-  manifest: MANIFEST4,
-  detect: detect4,
+  manifest: MANIFEST6,
+  detect: detect6,
   identifiesCommand,
-  verify: verify4,
+  verify: verify6,
   collectMetrics,
   plan,
   plansWithoutOwnership: true
@@ -5819,6 +7196,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 +7212,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 +7346,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,7 +7389,8 @@ function buildRtkPlan(input) {
 // packages/adapters/dist/src/providers/rtk.js
 var RTK2 = providerId("rtk");
 var CLAUDE3 = harnessId("claude");
-var MANIFEST5 = {
+var OPENCODE3 = harnessId("opencode");
+var MANIFEST7 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
   id: RTK2,
   displayName: "RTK",
@@ -6047,10 +7428,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 +7484,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: [
@@ -6101,11 +7550,12 @@ var MANIFEST5 = {
     // location differs per platform; `rtkDatabasePath` is the single derivation.
     locations: ["<user data directory>/rtk/history.db"]
   },
-  delegatedInstallReview: null
+  delegatedInstallReviews: null
 };
-var TESTED_VERSIONS2 = { minimum: "0.40.0", maximum: "0.42.0" };
-var VERSION_PATTERN5 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
+var TESTED_VERSIONS2 = { minimum: "0.40.0", maximum: "0.44.0" };
+var VERSION_PATTERN7 = /(\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 +7598,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);
     }
   }
@@ -6175,17 +7625,17 @@ async function readVersion(context) {
       ]
     };
   }
-  const version2 = VERSION_PATTERN5.exec(outcome2.stdout)?.[1] ?? null;
+  const version3 = VERSION_PATTERN7.exec(outcome2.stdout)?.[1] ?? null;
   return {
-    version: version2,
-    verdict: version2 === null ? null : classifyVersion(version2, TESTED_VERSIONS2),
+    version: version3,
+    verdict: version3 === null ? null : classifyVersion(version3, TESTED_VERSIONS2),
     executable: outcome2.executablePath,
     evidence: [
       evidence({
         kind: "version-output",
         source: "rtk --version",
         path: outcome2.executablePath,
-        detail: version2 === null ? "reported no recognisable version" : `reported ${version2}`
+        detail: version3 === null ? "reported no recognisable version" : `reported ${version3}`
       })
     ]
   };
@@ -6221,11 +7671,11 @@ async function readAnalytics(context) {
     ]
   };
 }
-async function detect5(context) {
+async function detect7(context) {
   const evidenceItems = [];
   const warnings = [];
-  const version2 = await readVersion(context);
-  evidenceItems.push(...version2.evidence);
+  const version3 = await readVersion(context);
+  evidenceItems.push(...version3.evidence);
   const configured = harnessesWiredToRtk(context.harnessConfigs);
   for (const harness of configured) {
     evidenceItems.push(evidence({
@@ -6235,15 +7685,15 @@ async function detect5(context) {
       detail: "names rtk in a hook command"
     }));
   }
-  if (version2.verdict === "unknown-newer") {
+  if (version3.verdict === "unknown-newer") {
     warnings.push(diagnostic({
       severity: "warning",
       code: "provider-version-unknown-newer",
-      message: `RTK ${String(version2.version)} is newer than the versions Token Harness has observed (up to ${TESTED_VERSIONS2.maximum})`,
+      message: `RTK ${String(version3.version)} is newer than the versions Token Harness has observed (up to ${TESTED_VERSIONS2.maximum})`,
       remediation: "Check the release notes for analytics or hook changes before applying a plan"
     }));
   }
-  const state = version2.version === null ? configured.length > 0 ? "broken" : "absent" : configured.length > 0 ? "configured" : "installed";
+  const state = version3.version === null ? configured.length > 0 ? "broken" : "absent" : configured.length > 0 ? "configured" : "installed";
   if (state === "broken") {
     warnings.push(diagnostic({
       severity: "error",
@@ -6256,36 +7706,61 @@ async function detect5(context) {
   return {
     providerId: RTK2,
     state,
-    version: version2.version,
-    executable: version2.executable,
+    version: version3.version,
+    executable: version3.executable,
     // Detection reports what it saw; which channel installed it is an installation-stage
     // question and guessing it from a path would be a guess.
     installationChannel: null,
-    versionVerdict: version2.verdict,
+    versionVerdict: version3.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,
+    /**
+     * Claude Code alone, 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. What does
+     * decide it is which harness schema that builder knows, and it knows one: `HOOK_LIST_HARNESSES`
+     * holds `claude` and the builder refuses anything else, because a `{matcher, hooks:[…]}` object
+     * at `hooks.<event>` is Claude Code's schema and nothing else's.
+     *
+     * RTK claims OpenCode too, from spike 9.1, and that claim is real — detected, adopted, verified
+     * and measured there. It is simply not *written* there: its OpenCode integration is a plugin
+     * module `rtk init -g --opencode` installs globally, which this build has no action for. Saying
+     * so here is what stops the resolver assigning a scope nothing can produce.
+     */
+    assignableHarnesses: [CLAUDE3],
     evidence: evidenceItems,
     warnings
   };
 }
-async function verify5(context) {
+async function verify7(context) {
   const checks = [];
   const diagnostics = [];
-  const version2 = await readVersion(context);
+  const version3 = await readVersion(context);
   checks.push({
     id: "executable-resolves",
-    status: version2.version === null ? "fail" : "pass",
-    summary: version2.version === null ? "rtk could not be run" : `rtk ${version2.version}`,
-    achievedTier: version2.version === null ? null : "presence",
-    evidence: version2.evidence,
-    remediation: version2.version === null ? "Install RTK, or add it to PATH" : null
+    status: version3.version === null ? "fail" : "pass",
+    summary: version3.version === null ? "rtk could not be run" : `rtk ${version3.version}`,
+    achievedTier: version3.version === null ? null : "presence",
+    evidence: version3.evidence,
+    remediation: version3.version === null ? "Install RTK, or add it to PATH" : null
   });
   const configured = harnessesWiredToRtk(context.harnessConfigs);
   checks.push({
@@ -6392,7 +7867,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,22 +8057,22 @@ 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);
+  const version3 = await readVersion(context);
   return buildRtkPlan({
     context,
     request,
-    installed: version2.version !== null,
+    installed: version3.version !== null,
     identifiesCommand: identifiesCommand2,
-    installationChannels: MANIFEST5.installationChannels
+    installationChannels: MANIFEST7.installationChannels
   });
 }
 var rtkAdapter = {
-  manifest: MANIFEST5,
-  detect: detect5,
-  verify: verify5,
+  manifest: MANIFEST7,
+  detect: detect7,
+  verify: verify7,
   collectMetrics: collectMetrics2,
   identifiesCommand: identifiesCommand2,
   plan: plan2
@@ -6611,7 +8086,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 +8112,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 +8119,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, new Set(detection.assignableHarnesses));
     }
   }
+  const providers = providerAdapters.map((adapter) => ({
+    id: adapter.manifest.id,
+    capabilities: adapter.manifest.capabilities,
+    assignableHarnesses: assignable.get(adapter.manifest.id) ?? /* @__PURE__ */ new Set()
+  }));
   const resolution = resolveOwnership({
     profile,
     harnesses: present,
@@ -6665,7 +8141,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 +8153,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 +8239,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 +8247,15 @@ async function computePlan(context) {
       remediation: null
     }));
   }
+  const refusalIsTheOutcome = actions.length === 0;
+  for (const entry of blocked) {
+    diagnostics.push(diagnostic({
+      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"
+    }));
+  }
   for (const conflict of resolution.conflicts) {
     diagnostics.push(diagnostic({
       severity: "error",
@@ -6749,7 +8264,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 +8289,11 @@ 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 = planExitCode({
+    blocked: computed.blocked.length,
+    actions: report.actions.length,
+    conflicts: report.conflicts.length
+  });
   return commandResult({
     command: "plan",
     exitCode,
@@ -6782,6 +8301,13 @@ async function runPlan(context) {
     diagnostics: computed.diagnostics
   });
 }
+function planExitCode(counts) {
+  if (counts.blocked > 0 && counts.actions === 0)
+    return EXIT_CODES["unsupported-environment"];
+  if (counts.conflicts > 0)
+    return EXIT_CODES["blocked-by-conflict"];
+  return EXIT_CODES.ok;
+}
 
 // apps/cli/dist/src/commands/apply.js
 var PLANS_DIRECTORY = "plans";
@@ -6845,6 +8371,9 @@ async function runApply(context) {
   const diagnostics = [];
   const computed = await computePlan(context);
   diagnostics.push(...computed.diagnostics);
+  if (computed.blocked.length > 0 && computed.report.actions.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 +8528,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 +8653,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 +8813,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 +8940,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 +8977,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 +8988,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,
+      assignableHarnesses: new Set(detection.assignableHarnesses)
+    });
   }
   const resolution = resolveOwnership({
     profile: "safe",
@@ -7461,14 +9053,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 +9334,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 +9536,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 +10204,7 @@ function usageText(topic) {
 }
 
 // apps/cli/dist/src/version.js
-var TOOL_VERSION = "0.1.1";
+var TOOL_VERSION = "0.1.3";
 
 // apps/cli/dist/src/run.js
 var DEFAULT_COMMANDS = {
@@ -8786,7 +10381,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;