token-harness 0.1.0 → 0.1.2

package/token-harness.mjs

@@ -111,6 +111,113 @@ function classifyVersion(observed, range) {
   return compareVersions(version2, maximum) > 0 ? "unknown-newer" : "in-range";
 }
 
+// packages/core/dist/src/domain/compatibility-rows.js
+var COMPATIBILITY_ROWS = [
+  {
+    harness: "claude",
+    harnessVersion: { minimum: "2.1.220", maximum: "2.1.220" },
+    provider: "rtk",
+    providerVersion: "0.44.0",
+    platform: { os: "windows", wsl: false, supported: true, limitation: null },
+    configSchema: "claude-settings-json-hooks",
+    fixture: "tests/fixtures/rows/rtk-claude-windows",
+    verificationTier: "canary"
+  },
+  {
+    harness: "claude",
+    harnessVersion: { minimum: "2.1.220", maximum: "2.1.220" },
+    provider: "harnesstrim",
+    providerVersion: "0.1.0",
+    platform: { os: "windows", wsl: false, supported: true, limitation: null },
+    // The install writes skill files, not a document this build parses, so the schema it depends on
+    // is the skills directory layout rather than `settings.json`.
+    configSchema: "claude-skills-directory",
+    fixture: "tests/fixtures/rows/harnesstrim-claude-windows",
+    verificationTier: "config-only"
+  }
+];
+function classifyRowHarnessVersion(rows, observed) {
+  if (rows.length === 0)
+    return null;
+  const parsed = parseSemanticVersion(observed);
+  if (parsed === null)
+    return null;
+  let lowestMinimum = null;
+  let highestMaximum = null;
+  for (const row2 of rows) {
+    const minimum = parseSemanticVersion(row2.harnessVersion.minimum);
+    const maximum = parseSemanticVersion(row2.harnessVersion.maximum);
+    if (minimum === null || maximum === null)
+      continue;
+    if (compareVersions(parsed, minimum) >= 0 && compareVersions(parsed, maximum) <= 0)
+      return "in-row";
+    if (lowestMinimum === null || compareVersions(minimum, lowestMinimum) < 0)
+      lowestMinimum = minimum;
+    if (highestMaximum === null || compareVersions(maximum, highestMaximum) > 0)
+      highestMaximum = maximum;
+  }
+  if (lowestMinimum === null || highestMaximum === null)
+    return null;
+  if (compareVersions(parsed, lowestMinimum) < 0)
+    return "unknown-older";
+  if (compareVersions(parsed, highestMaximum) > 0)
+    return "unknown-newer";
+  return "below-range";
+}
+function rowsFor(rows, combination) {
+  return rows.filter((row2) => row2.provider === combination.provider && row2.harness === combination.harness && row2.platform.os === combination.os && row2.platform.wsl === combination.wsl && row2.platform.supported);
+}
+function admitManagedMutation(rows, combination) {
+  const keyed = rowsFor(rows, combination);
+  if (combination.providerVersion === null)
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: "the exact provider version a row would record could not be established"
+    };
+  if (combination.harnessVersion === null)
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: "the exact harness version a row would cover could not be established"
+    };
+  if (keyed.length === 0)
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: `a reviewed config schema and fixture for ${combination.provider} on ${combination.harness} at ${combination.providerVersion} on ${combination.os}`
+    };
+  const versioned = keyed.filter((row3) => row3.providerVersion === combination.providerVersion);
+  if (versioned.length === 0) {
+    const fixture = keyed[0]?.fixture ?? "a provider fixture";
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: `a provider fixture covering ${combination.provider} at ${combination.providerVersion} (the nearest row's fixture is ${JSON.stringify(fixture)})`
+    };
+  }
+  const parsedHarness = parseSemanticVersion(combination.harnessVersion);
+  const row2 = versioned.find((candidate) => {
+    const minimum = parseSemanticVersion(candidate.harnessVersion.minimum);
+    const maximum = parseSemanticVersion(candidate.harnessVersion.maximum);
+    return minimum !== null && maximum !== null && parsedHarness !== null && compareVersions(parsedHarness, minimum) >= 0 && compareVersions(parsedHarness, maximum) <= 0;
+  });
+  if (row2 !== void 0)
+    return { state: "admitted", row: row2 };
+  const verdict = parsedHarness === null ? null : classifyRowHarnessVersion(versioned, combination.harnessVersion);
+  if (verdict === null || verdict === "in-row")
+    return {
+      state: "refused",
+      verdict: "no-row",
+      missing: `a reviewed config schema and fixture for ${combination.provider} on ${combination.harness}`
+    };
+  return {
+    state: "refused",
+    verdict,
+    missing: verdict === "unknown-newer" ? `a harness schema for ${combination.harness} newer than every row's maximum (the newest row names schema ${JSON.stringify(versioned[0]?.configSchema ?? "none")})` : verdict === "unknown-older" ? `a harness schema for ${combination.harness} older than every row's minimum (the oldest row names schema ${JSON.stringify(versioned[0]?.configSchema ?? "none")})` : `a harness schema covering ${combination.harness} at ${combination.harnessVersion}, between the rows that name schemas ${JSON.stringify(keyed.map((entry) => entry.configSchema))}`
+  };
+}
+
 // packages/core/dist/src/domain/compatibility.js
 function coversHarness(rule, harness) {
   return rule.harnesses === "*" || rule.harnesses.includes(harness);
@@ -155,6 +262,7 @@ function diagnostic(init) {
     severity: init.severity,
     code: init.code,
     message: init.message,
+    subject: init.subject ?? null,
     path: init.path ?? null,
     remediation: init.remediation ?? null
   };
@@ -206,6 +314,7 @@ function harnessId(value) {
   }
   return value;
 }
+var UNATTRIBUTED_PROJECT_ID = "p_unattributed";
 
 // packages/core/dist/src/domain/manifest.js
 var MANIFEST_SCHEMA_VERSION = 1;
@@ -263,6 +372,9 @@ function isStartableExecutable(resolved) {
 // packages/core/dist/src/domain/process.js
 var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
 var DEFAULT_PROCESS_TIMEOUT_MS = 3e4;
+function processSucceeded(outcome2) {
+  return outcome2.failure === null && outcome2.exitCode === 0;
+}
 
 // packages/core/dist/src/domain/redaction.js
 var REDACTED = "[redacted]";
@@ -584,12 +696,13 @@ function resolveOwnership(input) {
             continue;
           }
           if (!provider.assignable) {
+            const observed = input.observedVersions[provider.id] ?? null;
             exclusions.push({
               scope,
               excluded: provider.id,
               retained: null,
               reason: [
-                `${provider.id} implements ${capability} but no installer state produces it in isolation`,
+                observed === null ? `${provider.id} implements ${capability} but no installer state this build could observe produces it in isolation` : `${provider.id} ${observed} implements ${capability} but no installer state at that version produces it in isolation`,
                 "RFC 0003: a capability the provider has but cannot be asked for is not an assignable capability",
                 "It is still detected, adopted, reconciled against the owner, and measured"
               ]
@@ -630,6 +743,7 @@ function resolveOwnership(input) {
       }
     }
   }
+  narrowChannelOverlaps({ ownership, exclusions, conflicts, input });
   const ownerByScope = new Map(ownership.map((entry) => [formatCapabilityScope(entry.scope), entry.owner]));
   for (const exclusion of exclusions) {
     if (exclusion.retained !== null)
@@ -640,6 +754,66 @@ function resolveOwnership(input) {
   }
   return { ownership, exclusions, conflicts, pipelineId: derivePipelineId(ownership) };
 }
+function narrowChannelOverlaps(context) {
+  const { ownership, exclusions, conflicts, input } = context;
+  const channels = /* @__PURE__ */ new Map();
+  for (const entry of ownership) {
+    if (entry.mode !== "exclusive")
+      continue;
+    const key = `${entry.scope.harness}/${entry.scope.toolFamily}/${entry.scope.capability}`;
+    const group = channels.get(key) ?? [];
+    group.push(entry);
+    channels.set(key, group);
+  }
+  const dropped = /* @__PURE__ */ new Set();
+  for (const group of channels.values()) {
+    const owners = [...new Set(group.map((entry) => entry.owner))];
+    if (owners.length < 2)
+      continue;
+    const first = group[0];
+    if (first === void 0)
+      continue;
+    const { harness, toolFamily, capability } = first.scope;
+    const rule = findCompatibilityRule(input.rules, { providers: owners, harness, capability });
+    if (rule === null || rule.outcome !== "narrowed" || rule.retains === void 0) {
+      conflicts.push({
+        code: "exclusive-scope-contested",
+        scope: `${harness}/${toolFamily}/${capability}`,
+        claimants: [...owners].sort(),
+        detail: [
+          `${owners.join(" and ")} each own ${capability} on ${harness}/${toolFamily}, at different interception points`,
+          "The interception points differ but the payload does not, so the reduction would run twice",
+          rule === null ? "No rule names this pair on this channel, and an unreviewed overlap is not permission" : `Rule ${rule.id} does not say which provider keeps the channel`
+        ],
+        remediation: `Choose one owner for ${harness}/${toolFamily}/${capability} with \`profile: custom\``
+      });
+      for (const entry of group)
+        dropped.add(entry);
+      continue;
+    }
+    const retains = rule.retains;
+    for (const entry of group) {
+      if (entry.owner === retains)
+        continue;
+      dropped.add(entry);
+      exclusions.push({
+        scope: entry.scope,
+        excluded: entry.owner,
+        retained: retains,
+        reason: [
+          `rule ${rule.id} keeps ${capability} on ${harness}/${toolFamily} with ${retains}, at every interception point`,
+          `${entry.owner} is narrowed to the install its own flags produce rather than excluded whole`,
+          rule.rationale
+        ]
+      });
+    }
+  }
+  if (dropped.size > 0) {
+    const kept = ownership.filter((entry) => !dropped.has(entry));
+    ownership.length = 0;
+    ownership.push(...kept);
+  }
+}
 function resolveContested(context) {
   const { scope, claims, capability, input, ownership, exclusions, conflicts } = context;
   const claimants = claims.map((claim) => claim.provider);
@@ -715,6 +889,41 @@ function resolveContested(context) {
     }
     return;
   }
+  if (rule.outcome === "narrowed") {
+    const retains = rule.retains;
+    if (retains === void 0) {
+      conflicts.push({
+        code: "compatibility-rule-malformed",
+        scope: formatCapabilityScope(scope),
+        claimants,
+        detail: [
+          `Rule ${rule.id} narrows a pair without naming which provider keeps the channel`,
+          "Choosing one here would make the resolver decide what the rule exists to record"
+        ],
+        remediation: `Fix rule ${rule.id} so it names the provider that retains the capability`
+      });
+      return;
+    }
+    for (const claimant of claimants) {
+      if (claimant === retains)
+        continue;
+      exclusions.push({
+        scope,
+        excluded: claimant,
+        retained: retains,
+        reason: [
+          `rule ${rule.id} keeps ${capability} on ${scope.harness} with ${retains}`,
+          `${claimant} is narrowed to the install its own flags produce rather than excluded whole`,
+          rule.rationale
+        ]
+      });
+    }
+    const retainedClaim = claims.find((claim) => claim.provider === retains);
+    if (retainedClaim !== void 0) {
+      ownership.push({ scope, owner: retains, mode: retainedClaim.mode, order: 0 });
+    }
+    return;
+  }
   const winner = rule.providers.find((provider) => claimants.includes(provider)) ?? claimants[0];
   for (const claimant of claimants) {
     if (claimant === winner)
@@ -745,9 +954,10 @@ var RTK_HARNESSTRIM_SHELL_OVERLAP = {
   // for different reasons. Listing them individually would imply a fourth harness is exempt.
   harnesses: "*",
   capabilities: ["shell.output.reduce"],
-  outcome: "conflict",
-  testedVersions: { rtk: "0.42.0", harnesstrim: "0.0.5" },
-  rationale: "HarnessTrim 0.0.5 reduces the same command output RTK already reduced, and no configuration narrows it: its Claude and Codex adapters match Bash only, and its OpenCode plugin reduces every tool result. Reducing an already reduced payload loses signal and counts the saving twice.",
+  outcome: "narrowed",
+  retains: RTK,
+  testedVersions: { rtk: "0.44.0", harnesstrim: "0.1.0" },
+  rationale: "RTK keeps shell output reduction: it rewrites the command, so the output arriving at any later point is already reduced, and reducing it again loses signal and counts the saving twice. HarnessTrim 0.1.0 no longer has to be excluded whole for that \u2014 `--no-hook` and `--no-instructions` produce a Claude install that adds skills and reduces nothing, and `--tools` confines its OpenCode reduction to a chosen tool family. So it is narrowed to the form that leaves this channel alone, rather than refused. At 0.0.5 no flag produced any of those states, which is why this rule read `conflict` and said no configuration narrows it.",
   fixtures: ["docs/rfcs/0003-capabilities-and-conflicts.md#the-table-is-an-intent"]
 };
 var COMPATIBILITY_RULES = [RTK_HARNESSTRIM_SHELL_OVERLAP];
@@ -882,12 +1092,12 @@ function isUsableSalt(value) {
 }
 
 // packages/core/dist/src/metrics/local-database.js
-function numberAt(row, column2) {
-  const value = row[column2];
+function numberAt(row2, column2) {
+  const value = row2[column2];
   return typeof value === "number" ? value : null;
 }
-function stringAt(row, column2) {
-  const value = row[column2];
+function stringAt(row2, column2) {
+  const value = row2[column2];
   return typeof value === "string" ? value : null;
 }
 
@@ -988,7 +1198,7 @@ function aggregateEvents(input) {
   const managed = new Set(input.managedProviders ?? []);
   const modes = input.adapterModes ?? {};
   const classes = MEASUREMENT_CLASSES.map((measurementClass) => {
-    const rows = [...classTotals.values()].filter((row2) => row2.class === measurementClass);
+    const rows = [...classTotals.values()].filter((row3) => row3.class === measurementClass);
     if (rows.length > 1) {
       return {
         class: measurementClass,
@@ -996,11 +1206,11 @@ function aggregateEvents(input) {
         before: null,
         after: null,
         saved: null,
-        note: `recorded in ${rows.map((row2) => row2.unit).join(" and ")}, which are not addable`
+        note: `recorded in ${rows.map((row3) => row3.unit).join(" and ")}, which are not addable`
       };
     }
-    const row = rows[0];
-    if (row === void 0) {
+    const row2 = rows[0];
+    if (row2 === void 0) {
       return {
         class: measurementClass,
         unit: null,
@@ -1012,22 +1222,22 @@ function aggregateEvents(input) {
     }
     return {
       class: measurementClass,
-      unit: row.unit,
-      before: row.before,
-      after: row.after,
-      saved: row.before - row.after,
+      unit: row2.unit,
+      before: row2.before,
+      after: row2.after,
+      saved: row2.before - row2.after,
       note: null
     };
   });
-  const providers = [...providerTotals.values()].sort((left, right) => right.saved - left.saved || left.providerId.localeCompare(right.providerId)).map((row) => ({
-    providerId: row.providerId,
-    saved: row.saved,
-    unit: row.unit,
-    class: row.class,
-    operations: row.operations,
-    harnesses: [...row.harnesses].sort(),
-    managedByTokenHarness: managed.has(row.providerId),
-    adapterMode: modes[row.providerId] ?? null
+  const providers = [...providerTotals.values()].sort((left, right) => right.saved - left.saved || left.providerId.localeCompare(right.providerId)).map((row2) => ({
+    providerId: row2.providerId,
+    saved: row2.saved,
+    unit: row2.unit,
+    class: row2.class,
+    operations: row2.operations,
+    harnesses: [...row2.harnesses].sort(),
+    managedByTokenHarness: managed.has(row2.providerId),
+    adapterMode: modes[row2.providerId] ?? null
   }));
   const operations = realized + bypassed;
   return {
@@ -1266,6 +1476,201 @@ async function queryAvailableVersion(input) {
   }
   return { status: "found", version: version2, destination, diagnostics };
 }
+var INVENTORY_COMMANDS = {
+  /**
+   * `winget list --id <id> --exact` prints the same dashes-anchored table as `show --versions`,
+   * with the installed version as the last token of the row. The header is localized, which is
+   * why the parse is anchored on the separator and the row tail rather than on a column title.
+   *
+   * A missing package makes winget exit non-zero with a localized "no package found" message,
+   * which this build cannot tell from any other failure — so that case is `failed` at the caller,
+   * never `absent`.
+   */
+  winget: {
+    executable: "winget",
+    args: (packageName) => ["list", "--id", packageName, "--exact"],
+    parse: (stdout, _packageName) => {
+      const lines = stdout.split(/\r?\n/);
+      const separator = lines.findIndex((line) => /^-{3,}\s*$/.test(line.trim()));
+      if (separator < 0)
+        return { status: "unknown", version: null };
+      for (const line of lines.slice(separator + 1)) {
+        const row2 = line.trim();
+        if (row2 === "")
+          continue;
+        const candidate = row2.split(/\s+/).at(-1) ?? "";
+        if (parseSemanticVersion(candidate) === null)
+          return { status: "unknown", version: null };
+        return { status: "captured", version: candidate };
+      }
+      return { status: "unknown", version: null };
+    },
+    verified: false
+  },
+  /**
+   * `cargo install --list` prints one `crate v0.1.0:` line per installed crate, so absence is a
+   * positive answer: the crate simply does not appear. This is the one inventory among the six
+   * that can confirm absence.
+   */
+  cargo: {
+    executable: "cargo",
+    args: () => ["install", "--list"],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^\\s*${packageName}\\s+v(\\S+)\\s*:`, "m");
+      const match = pattern.exec(stdout);
+      if (match === null)
+        return { status: "absent", version: null };
+      const candidate = match[1] ?? "";
+      if (parseSemanticVersion(candidate) === null)
+        return { status: "unknown", version: null };
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  },
+  npm: {
+    executable: "npm",
+    args: (packageName) => ["ls", "-g", packageName, "--depth=0"],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`(?:^|[^@\\w.-])${packageName}@(\\d[^\\s]*)`);
+      const match = pattern.exec(stdout);
+      const candidate = match?.[1] ?? null;
+      if (candidate === null || parseSemanticVersion(candidate) === null) {
+        return { status: "unknown", version: null };
+      }
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  },
+  homebrew: {
+    executable: "brew",
+    args: (packageName) => ["list", "--versions", packageName],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^${packageName}\\s+(.+)$`);
+      const match = pattern.exec(stdout.trim());
+      const candidate = match?.[1]?.trim().split(/\s+/).at(-1) ?? null;
+      if (candidate === null || parseSemanticVersion(candidate) === null) {
+        return { status: "unknown", version: null };
+      }
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  },
+  uv: {
+    executable: "uv",
+    args: () => ["tool", "list"],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^${packageName}\\s+v?(\\S+)`, "m");
+      const match = pattern.exec(stdout);
+      if (match === null)
+        return { status: "absent", version: null };
+      const candidate = match[1] ?? "";
+      if (parseSemanticVersion(candidate) === null)
+        return { status: "unknown", version: null };
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  },
+  pipx: {
+    executable: "pipx",
+    args: () => ["list"],
+    parse: (stdout, packageName) => {
+      const pattern = new RegExp(`^\\s*${packageName}\\s+(\\S+)`, "m");
+      const match = pattern.exec(stdout);
+      if (match === null)
+        return { status: "absent", version: null };
+      const candidate = match[1] ?? "";
+      if (parseSemanticVersion(candidate) === null)
+        return { status: "unknown", version: null };
+      return { status: "captured", version: candidate };
+    },
+    verified: false
+  }
+};
+function channelCanReportInventory(channelId) {
+  return Object.hasOwn(INVENTORY_COMMANDS, channelId);
+}
+var DEFAULT_INVENTORY_TIMEOUT_MS = 6e4;
+async function queryPackageInventory(input) {
+  const recipe = INVENTORY_COMMANDS[input.channel];
+  if (recipe === void 0) {
+    return {
+      channel: input.channel,
+      packageName: input.packageName,
+      status: "unsupported",
+      version: null,
+      diagnostics: [
+        diagnostic({
+          severity: "warning",
+          code: "inventory-query-unsupported",
+          message: `This build cannot ask ${input.channel} what it has installed`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  if (input.runner === null) {
+    return {
+      channel: input.channel,
+      packageName: input.packageName,
+      status: "failed",
+      version: null,
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "no-process-runner",
+          message: "No process runner is available, so no inventory can be captured",
+          remediation: null
+        })
+      ]
+    };
+  }
+  const diagnostics = [];
+  if (!recipe.verified) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "inventory-query-unverified",
+      message: `The ${input.channel} inventory query follows that tool's documented output but has not been observed working`,
+      remediation: "Confirm the rollback receipt after any failure"
+    }));
+  }
+  const outcome2 = await input.runner.run({
+    executable: recipe.executable,
+    args: recipe.args(input.packageName),
+    cwd: input.cwd,
+    timeoutMs: input.timeoutMs ?? DEFAULT_INVENTORY_TIMEOUT_MS
+  });
+  if (outcome2.failure !== null || outcome2.exitCode !== 0) {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "inventory-query-failed",
+      message: outcome2.failure === null ? `${outcome2.displayCommand} exited with ${String(outcome2.exitCode)}` : `${recipe.executable} could not be run: ${outcome2.failure.reason}`,
+      remediation: null
+    }));
+    return {
+      channel: input.channel,
+      packageName: input.packageName,
+      status: "failed",
+      version: null,
+      diagnostics
+    };
+  }
+  const reading = recipe.parse(outcome2.stdout, input.packageName);
+  if (reading.status === "unknown") {
+    diagnostics.push(diagnostic({
+      severity: "warning",
+      code: "inventory-query-unreadable",
+      message: `${recipe.executable} answered, but its output did not name an installed version in the form this build reads`,
+      remediation: null
+    }));
+  }
+  return {
+    channel: input.channel,
+    packageName: input.packageName,
+    status: reading.status,
+    version: reading.version,
+    diagnostics
+  };
+}
 var DEFAULT_INSTALL_TIMEOUT_MS = 6e5;
 async function runPackageManagerInstall(input) {
   const { action } = input;
@@ -1345,14 +1750,119 @@ async function runPackageManagerInstall(input) {
     }));
     return { status: "failed", diagnostics };
   }
-  diagnostics.push(diagnostic({
-    severity: "info",
-    code: "install-not-reversible",
-    message: `${action.packageName} was installed through ${action.packageManager}; a rollback restores files and will not uninstall it`,
-    remediation: null
-  }));
   return { status: "installed", diagnostics };
 }
+async function restorePackageInventory(input) {
+  const { capture } = input;
+  if (capture.status === "absent") {
+    return {
+      restored: false,
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: "package-inventory-unrestored",
+          message: `${capture.packageName} was not installed before the transaction; restoring that absence would require an uninstall command, so it stays installed`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  if (capture.status !== "captured" || capture.version === null) {
+    return {
+      restored: false,
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: "package-inventory-unrestored",
+          message: `${capture.packageName} was installed without a captured inventory, so it could not be restored`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  if (input.runner === null) {
+    return {
+      restored: false,
+      diagnostics: [
+        diagnostic({
+          severity: "info",
+          code: "package-inventory-unrestored",
+          message: `${capture.packageName} could not be restored: no process runner is available`,
+          remediation: null
+        })
+      ]
+    };
+  }
+  const restoreAction = {
+    kind: "package-manager-install",
+    id: `restore-${capture.packageName}`,
+    riskClass: "delegated",
+    requiresNetwork: true,
+    requiresElevation: false,
+    affectedPaths: [],
+    affectedProcesses: [capture.channel],
+    preconditions: [],
+    postconditions: [],
+    rollbackData: "none",
+    explanation: `Restore ${capture.packageName} to ${capture.version} after a rollback`,
+    packageManager: capture.channel,
+    packageName: capture.packageName,
+    version: capture.version
+  };
+  const result = await runPackageManagerInstall({
+    action: restoreAction,
+    runner: input.runner,
+    cwd: input.cwd,
+    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
+  });
+  if (result.status !== "installed") {
+    return {
+      restored: false,
+      diagnostics: [
+        ...result.diagnostics,
+        diagnostic({
+          severity: "error",
+          code: "package-restore-failed",
+          message: `${capture.packageName} could not be restored to ${capture.version} through ${capture.channel}`,
+          path: null,
+          remediation: `Install ${capture.packageName} at ${capture.version} yourself, then run the command again`
+        })
+      ]
+    };
+  }
+  const verified = await queryPackageInventory({
+    channel: capture.channel,
+    packageName: capture.packageName,
+    runner: input.runner,
+    cwd: input.cwd,
+    ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs }
+  });
+  if (verified.status !== "captured" || verified.version !== capture.version) {
+    return {
+      restored: false,
+      diagnostics: [
+        ...verified.diagnostics,
+        diagnostic({
+          severity: "error",
+          code: "package-restore-failed",
+          message: `${capture.packageName} was reinstalled but the inventory does not report ${capture.version}`,
+          remediation: `Confirm what ${capture.channel} has installed and correct it by hand`
+        })
+      ]
+    };
+  }
+  return {
+    restored: true,
+    diagnostics: [
+      diagnostic({
+        severity: "info",
+        code: "package-inventory-restored",
+        message: `${capture.packageName} was restored to ${capture.version} through ${capture.channel} and the inventory was re-read`,
+        remediation: null
+      })
+    ]
+  };
+}
 
 // packages/core/dist/src/state/json-merge.js
 function isJsonObject(value) {
@@ -1772,7 +2282,8 @@ function outcome(action, status, parts = {}) {
     status,
     snapshots: parts.snapshots ?? [],
     ownership: parts.ownership ?? [],
-    diagnostics: parts.diagnostics ?? []
+    diagnostics: parts.diagnostics ?? [],
+    packageInventory: parts.packageInventory ?? null
   };
 }
 function drift(action, path, message) {
@@ -2037,6 +2548,141 @@ async function applyRemoveOwnedChange(action, context) {
   await fs.writeFile(action.target.path, UTF8.encode(removal.text), null);
   return outcome(action, "applied", { snapshots: [snapshot] });
 }
+async function scanTree(fs, path, entries = []) {
+  const stat3 = await fs.stat(path);
+  if (stat3 === null)
+    return entries;
+  const digest = stat3.kind === "file" ? digestBytes(await fs.readFile(path)) : null;
+  entries.push({ path, kind: stat3.kind, digest, byteLength: stat3.byteLength });
+  if (stat3.kind === "directory") {
+    for (const child of await fs.readDirectory(path)) {
+      await scanTree(fs, fs.join(path, child), 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) {
+  if (context.runner === null || context.runner === void 0 || context.cwd === void 0) {
+    return refusal(action, "process-runner-unavailable", action.executable, "A delegated provider install requires a process runner and working directory", "Run this command through the Token Harness CLI");
+  }
+  const before = /* @__PURE__ */ new Map();
+  for (const boundary of action.containmentBoundary) {
+    for (const entry of await scanTree(context.fs, boundary))
+      before.set(entry.path, entry);
+  }
+  if (action.expectedArtifacts.every((artifact) => before.get(artifact.path)?.kind === "file" && before.get(artifact.path)?.digest === artifact.digest)) {
+    return outcome(action, "already-satisfied");
+  }
+  const bytes = [...before.values()].reduce((total, entry) => total + entry.byteLength, 0);
+  if (bytes > action.snapshotSizeCapBytes) {
+    return refusal(action, "delegated-install-snapshot-too-large", action.containmentBoundary[0] ?? action.executable, `The delegated install boundary is ${String(bytes)} bytes, above its ${String(action.snapshotSizeCapBytes)} byte snapshot cap`, "Narrow the provider containment boundary before applying this plan");
+  }
+  const snapshots = [];
+  const capturedPaths = /* @__PURE__ */ new Set();
+  for (const boundary of action.containmentBoundary) {
+    const entries = await scanTree(context.fs, boundary);
+    if (entries.length === 0) {
+      snapshots.push(await context.snapshots.capture(boundary));
+      capturedPaths.add(boundary);
+      continue;
+    }
+    for (const entry of entries) {
+      snapshots.push(await context.snapshots.capture(entry.path));
+      capturedPaths.add(entry.path);
+    }
+  }
+  const result = await context.runner.run({
+    executable: action.executable,
+    args: action.args,
+    cwd: context.cwd,
+    timeoutMs: 3e4
+  });
+  if (!processSucceeded(result)) {
+    return outcome(action, "failed", {
+      snapshots,
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "delegated-install-failed",
+          message: `${action.executable} did not complete its delegated install successfully`,
+          remediation: "Review the provider output and rerun the plan after correcting the problem"
+        })
+      ]
+    });
+  }
+  const after = /* @__PURE__ */ new Map();
+  for (const boundary of action.containmentBoundary) {
+    for (const entry of await scanTree(context.fs, boundary))
+      after.set(entry.path, entry);
+  }
+  for (const entry of after.values()) {
+    if (!before.has(entry.path) && !capturedPaths.has(entry.path)) {
+      snapshots.push(context.snapshots.captureAbsent(entry.path));
+      capturedPaths.add(entry.path);
+    }
+  }
+  const protectedPath = action.protectedPaths.find((path) => !equalTreeEntry(before.get(path), after.get(path)));
+  if (protectedPath !== void 0) {
+    return outcome(action, "failed", {
+      snapshots,
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "delegated-install-protected-path-changed",
+          message: `The delegated installer changed the protected path ${protectedPath}`,
+          path: protectedPath,
+          remediation: "Do not apply this provider until its reviewed write set is updated"
+        })
+      ]
+    });
+  }
+  const changed = /* @__PURE__ */ new Set([...before.keys(), ...after.keys()]);
+  const undeclared = [...changed].map((path) => after.get(path) ?? before.get(path)).find((entry) => entry !== void 0 && !equalTreeEntry(before.get(entry.path), after.get(entry.path)) && !action.expectedArtifacts.some((artifact) => artifact.path === entry.path || entry.kind === "directory" && context.fs.isInside(artifact.path, entry.path)));
+  if (undeclared !== void 0) {
+    return outcome(action, "failed", {
+      snapshots,
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "delegated-install-undeclared-write",
+          message: `The delegated installer changed an undeclared path inside its containment boundary: ${undeclared.path}`,
+          path: undeclared.path,
+          remediation: "Do not apply this provider until its reviewed write set is updated"
+        })
+      ]
+    });
+  }
+  const missing = action.expectedArtifacts.find((artifact) => after.get(artifact.path)?.kind !== "file" || after.get(artifact.path)?.digest !== artifact.digest);
+  if (missing !== void 0) {
+    return outcome(action, "failed", {
+      snapshots,
+      diagnostics: [
+        diagnostic({
+          severity: "error",
+          code: "delegated-install-artifact-mismatch",
+          message: `The delegated installer did not produce the reviewed artifact ${missing.path}`,
+          path: missing.path,
+          remediation: "Do not apply this provider until its reviewed artifact digests are updated"
+        })
+      ]
+    });
+  }
+  const ownership = [];
+  for (const artifact of action.expectedArtifacts) {
+    ownership.push({
+      kind: "owned-file",
+      path: artifact.path,
+      digest: artifact.digest,
+      mode: (await context.fs.stat(artifact.path))?.mode ?? null
+    });
+  }
+  return outcome(action, "applied", { snapshots, ownership });
+}
 function notImplemented(action) {
   return outcome(action, "failed", {
     diagnostics: [
@@ -2063,9 +2709,10 @@ async function applyAction(action, context) {
       return applyMergeJson(action, context);
     case "package-manager-install":
       return applyPackageManagerInstall(action, context);
+    case "delegated-provider-install":
+      return applyDelegatedProviderInstall(action, context);
     case "download-artifact":
     case "run-installer-command":
-    case "delegated-provider-install":
     case "merge-toml":
     case "merge-yaml":
     case "register-mcp-server":
@@ -2074,13 +2721,38 @@ async function applyAction(action, context) {
   }
 }
 async function applyPackageManagerInstall(action, context) {
+  const wantsInventory = action.rollbackData === "package-inventory" && !action.requiresElevation;
+  const packageInventory = wantsInventory && context.runner !== void 0 ? await queryPackageInventory({
+    channel: action.packageManager,
+    packageName: action.packageName,
+    runner: context.runner,
+    cwd: context.cwd ?? ""
+  }) : null;
   const result = await runPackageManagerInstall({
     action,
     runner: context.runner ?? null,
     cwd: context.cwd ?? ""
   });
   const status = result.status === "installed" ? "applied" : result.status === "refused" ? "refused" : "failed";
-  return outcome(action, status, { diagnostics: result.diagnostics });
+  const diagnostics = [...result.diagnostics];
+  if (status === "applied") {
+    if (packageInventory?.status === "captured" && packageInventory.version !== null) {
+      diagnostics.push(diagnostic({
+        severity: "info",
+        code: "install-inventory-captured",
+        message: `${action.packageName} was installed through ${action.packageManager}; the prior state (${packageInventory.version}) was captured, so a rollback can restore it`,
+        remediation: null
+      }));
+    } else {
+      diagnostics.push(diagnostic({
+        severity: "info",
+        code: "install-not-reversible",
+        message: `${action.packageName} was installed through ${action.packageManager}; a rollback restores files and will not uninstall it`,
+        remediation: null
+      }));
+    }
+  }
+  return outcome(action, status, { diagnostics, packageInventory });
 }
 
 // packages/core/dist/src/state/journal.js
@@ -2559,23 +3231,25 @@ var TransactionSnapshotStore = class _TransactionSnapshotStore {
     this.taken.push(snapshot);
     return snapshot;
   }
+  captureAbsent(path) {
+    return this.remember({
+      schemaVersion: 1,
+      path,
+      existed: false,
+      wasDirectory: false,
+      digest: null,
+      mode: null,
+      byteLength: null,
+      contentRef: null,
+      capturedAt: this.input.now()
+    });
+  }
   async capture(path) {
     const { fs } = this.input;
     const stat3 = await fs.stat(path);
     const capturedAt = this.input.now();
-    if (stat3 === null) {
-      return this.remember({
-        schemaVersion: 1,
-        path,
-        existed: false,
-        wasDirectory: false,
-        digest: null,
-        mode: null,
-        byteLength: null,
-        contentRef: null,
-        capturedAt
-      });
-    }
+    if (stat3 === null)
+      return this.captureAbsent(path);
     if (stat3.kind === "directory") {
       return this.remember({
         schemaVersion: 1,
@@ -2674,6 +3348,24 @@ async function verifyRestoration(fs, snapshots) {
   }
   return unrestored;
 }
+async function restorePackageInventories(records, runner, cwd) {
+  const diagnostics = [];
+  for (const record of records) {
+    if (record.kind !== "package-manager-install")
+      continue;
+    if (record.status !== "applied")
+      continue;
+    if (record.packageInventory === null || record.packageInventory === void 0)
+      continue;
+    const outcome2 = await restorePackageInventory({
+      capture: record.packageInventory,
+      runner,
+      cwd
+    });
+    diagnostics.push(...outcome2.diagnostics);
+  }
+  return diagnostics;
+}
 async function executeTransaction(request) {
   const startedAt = request.now();
   const entries = [];
@@ -2717,7 +3409,10 @@ async function executeTransaction(request) {
       restoreError = error instanceof Error ? error.message : String(error);
     }
     const unrestored = await verifyRestoration(request.fs, snapshots);
-    if (restoreError === null && unrestored.length === 0) {
+    const packageDiagnostics = await restorePackageInventories(applied, request.runner ?? null, request.projectRoot);
+    diagnostics.push(...packageDiagnostics);
+    const packageRestoreFailed = packageDiagnostics.some((entry) => entry.severity === "error");
+    if (restoreError === null && unrestored.length === 0 && !packageRestoreFailed) {
       diagnostics.push(diagnostic({
         severity: "info",
         code: "transaction-rolled-back",
@@ -2745,6 +3440,7 @@ async function executeTransaction(request) {
         status: "failed",
         snapshots: [],
         ownership: [],
+        packageInventory: null,
         diagnostics: [
           diagnostic({
             severity: "error",
@@ -2762,7 +3458,8 @@ async function executeTransaction(request) {
       status: result.status,
       snapshots: result.snapshots,
       ownership: result.ownership,
-      diagnostics: result.diagnostics
+      diagnostics: result.diagnostics,
+      packageInventory: result.packageInventory
     };
     entries.push(entry);
     applied.push(result);
@@ -2847,7 +3544,10 @@ async function rollbackTransaction(request) {
     restoreError = error instanceof Error ? error.message : String(error);
   }
   const unrestored = await verifyRestoration(request.fs, snapshots);
-  if (restoreError === null && unrestored.length === 0) {
+  const packageDiagnostics = await restorePackageInventories(journal.entries, request.runner ?? null, request.cwd ?? journal.projectRoot);
+  diagnostics.push(...packageDiagnostics);
+  const packageRestoreFailed = packageDiagnostics.some((entry) => entry.severity === "error");
+  if (restoreError === null && unrestored.length === 0 && !packageRestoreFailed) {
     journal.outcome = "rolled-back";
     journal.ownership = [];
     journal.finishedAt = request.now();
@@ -3168,9 +3868,9 @@ async function readLocalDatabase(request) {
     database = new construct(request.path, { readOnly: true });
     const statement = database.prepare(request.sql);
     const raw = statement.all(...request.parameters);
-    const rows = raw.map((row) => {
+    const rows = raw.map((row2) => {
       const mapped = {};
-      for (const [column2, value] of Object.entries(row))
+      for (const [column2, value] of Object.entries(row2))
         mapped[column2] = toValue(value);
       return mapped;
     });
@@ -4447,9 +5147,20 @@ async function inspect(context) {
     diagnostics.push(diagnostic({
       severity: "warning",
       code: "tool-family-not-covered",
-      message: `No configured matcher covers the ${uncoveredToolFamilies.join(", ")} tool ${uncoveredToolFamilies.length === 1 ? "family" : "families"}, so commands routed through ${uncoveredToolFamilies.length === 1 ? "it" : "them"} bypass the pipeline`,
+      subject: CLAUDE,
+      /**
+       * Says whose gap it is, and that the tool is working.
+       *
+       * The first wording — "No configured matcher covers the PowerShell tool family" — read like a
+       * defect in Token Harness on a first run. It is not: the hook in the file below matches some
+       * tool families and not others, Claude Code routes shell commands through more than one on
+       * Windows, and the commands going through the uncovered ones never reach the provider at all.
+       */
+      // Short enough to survive the one-line human rendering without being cut.
+      message: `${uncoveredToolFamilies.join(", ")} has no hook, so those commands are not optimized`,
       path: configs.find((config) => config.configuredPoints.length > 0)?.path ?? null,
-      remediation: "Widen the matcher, or accept the gap and read coverage figures with it in mind"
+      // Short on purpose: a remediation nobody finishes reading is not one.
+      remediation: "Optional. Widen the matcher, or accept the gap"
     }));
   }
   return {
@@ -4743,6 +5454,7 @@ async function inspect2(context) {
     diagnostic({
       severity: "info",
       code: "hook-enablement-unobservable",
+      subject: CODEX,
       message: "Codex declares this hook, but its persisted enablement and trust state cannot be read outside the TUI",
       path: hook.path,
       remediation: "Open Codex and confirm the hook is enabled and trusted after any hook edit"
@@ -4852,20 +5564,47 @@ var MANIFEST3 = {
    * configuration must be able to exit 0. A declared limitation is not a problem, and reporting
    * it as one is the fastest way to teach users to ignore the exit code."
    *
-   * A single point rather than a range, matching the Codex adapter: one version was observed, so
-   * one version is claimed. An older 1.x reports `unknown-older`, which is a warning and not a
+   * A range now, because spike 9.1 observed two more: the CLI at `1.18.11` and OpenCode Desktop at
+   * `1.18.14`, both loading plugins from the same directories. The span is what was watched, not a
+   * guess that every 1.18.x behaves alike — and the two ends differ in a way that matters, which is
+   * exactly why both are named. An older 1.x reports `unknown-older`, which is a warning and not a
    * problem, and a newer one reports `unknown-newer` — which is then a true statement.
    */
-  testedVersions: { minimum: "1.18.9", maximum: "1.18.9" },
+  testedVersions: { minimum: "1.18.9", maximum: "1.18.14" },
   // RFC 0007: a managed provider can emit a receipt, but an adopted generated wrapper
   // has no externally observable receipt. The harness adapter alone therefore declares
   // the achievable baseline, not a promise about a provider it does not own.
   verificationTier: "config-only",
   versionCommand: { executable: "opencode", args: ["--version"] },
-  interceptionPoints: [{ scopeId: "tool-execute-after", eventName: "tool.execute.after" }],
+  interceptionPoints: [
+    { scopeId: "tool-execute-before", eventName: "tool.execute.before" },
+    { scopeId: "tool-execute-after", eventName: "tool.execute.after" }
+  ],
+  /**
+   * Two kinds of entry, because OpenCode has two ways to register a plugin and only one of them is
+   * a document.
+   *
+   * The `opencode.jsonc` files carry a `plugin` string array. The directories are auto-loaded: any
+   * module dropped in one is registered without being named anywhere, which is how both real
+   * integrations install — `rtk init -g --opencode` writes `.config/opencode/plugins/rtk.ts` and
+   * touches no JSON at all, and HarnessTrim's generated wrapper says in its own header not to
+   * reference it from `opencode.json`. An adapter that read only the array would report every such
+   * installation as absent, which is the state this file was in before spike 9.1.
+   *
+   * Both spellings are listed because both load. Spike 9.1 put a probe in each and one run fired
+   * both; the upstream documentation names the plural, the binary carries both strings, and the two
+   * shipped integrations disagree with each other about which to use.
+   *
+   * `markers` is the parser because there is nothing to parse: the presence of a file is the
+   * configuration, and its contents are a plugin module rather than a document this build reads.
+   */
   configFiles: [
     { path: ".config/opencode/opencode.jsonc", scope: "user", parser: "jsonc", primary: true },
-    { path: "opencode.jsonc", scope: "project", parser: "jsonc", primary: false }
+    { path: "opencode.jsonc", scope: "project", parser: "jsonc", primary: false },
+    { path: ".config/opencode/plugins", scope: "user", parser: "markers", primary: false },
+    { path: ".config/opencode/plugin", scope: "user", parser: "markers", primary: false },
+    { path: ".opencode/plugins", scope: "project", parser: "markers", primary: false },
+    { path: ".opencode/plugin", scope: "project", parser: "markers", primary: false }
   ],
   toolFamilies: [
     { id: "tool.execute", platforms: ["windows", "macos", "linux"], executesShellCommands: true }
@@ -4882,7 +5621,38 @@ function pluginEntries(document2) {
     return [];
   return document2["plugin"].filter((item) => typeof item === "string");
 }
+var PLUGIN_MODULE_PATTERN = /\.(ts|js|mjs|cjs|mts|cts)$/i;
+var PLUGIN_POINTS = ["tool-execute-before", "tool-execute-after"];
+async function resolvePluginDirectory(declaration, context) {
+  const path = resolveConfigPath(declaration, context);
+  const stat3 = await context.fs.stat(path);
+  if (stat3 === null || stat3.kind !== "directory") {
+    return {
+      declaration,
+      path,
+      exists: false,
+      parsed: false,
+      configuredPoints: [],
+      matchers: [],
+      commands: []
+    };
+  }
+  const modules = (await context.fs.readDirectory(path)).filter((entry) => PLUGIN_MODULE_PATTERN.test(entry));
+  return {
+    declaration,
+    path,
+    exists: true,
+    // A directory listing cannot fail to parse. `markers` declares that there is nothing to read.
+    parsed: true,
+    configuredPoints: modules.length > 0 ? [...PLUGIN_POINTS] : [],
+    // The plugin API sees every tool result; this is not a shell matcher.
+    matchers: modules.length > 0 ? ["tool.execute"] : [],
+    commands: modules.map((entry) => context.fs.join(path, entry))
+  };
+}
 async function resolveConfig3(declaration, context) {
+  if (declaration.parser === "markers")
+    return resolvePluginDirectory(declaration, context);
   const path = resolveConfigPath(declaration, context);
   const stat3 = await context.fs.stat(path);
   if (stat3 === null || stat3.kind !== "file") {
@@ -4914,7 +5684,9 @@ async function resolveConfig3(declaration, context) {
     path,
     exists: true,
     parsed: true,
-    configuredPoints: plugins.length > 0 ? ["tool-execute-after"] : [],
+    // A `plugin` array entry is the same kind of thing as a module in a plugin directory: a
+    // registration whose hooks are only known once it runs. Same claim, same reason.
+    configuredPoints: plugins.length > 0 ? [...PLUGIN_POINTS] : [],
     // The plugin API sees every tool result; this is not a shell matcher.
     matchers: plugins.length > 0 ? ["tool.execute"] : [],
     commands: plugins
@@ -5072,8 +5844,24 @@ function listHarnessAdapters() {
 var HARNESSTRIM2 = providerId("harnesstrim");
 var CLAUDE2 = harnessId("claude");
 var CODEX2 = harnessId("codex");
+var CLAUDE_ARTIFACT_DIGESTS = {
+  "compact-handoff/SKILL.md": "sha256:0efbf35581c559359e755b204778b64a289dab4d20dadc1cba3d5b5c995b5f01",
+  "debug-log-slim/SKILL.md": "sha256:17f5ccc34d29d7aba083444e0e4d87fd3d49916ebcb4e6544caf8c89f13f0045",
+  "delegate-bulk/SKILL.md": "sha256:3753de2ad18271c24832e4cda63115d353620515d5d80f40e93bc07d2a7257d7",
+  "delta-response/SKILL.md": "sha256:b6a71f4bdcfcadde3b5242994baa017d0371fe11652dd763f55a2f6d3840cfa8",
+  "delta-response/references/examples.md": "sha256:c67a1f57e63550b396043c3072b7e1a3a0c1522376471f53d6829253339e64e7",
+  "review-delta/SKILL.md": "sha256:4dfbf9d6ec08dff27b4759726536b43928370e288706fa01f5b498648e741388",
+  "scaffold-fast/SKILL.md": "sha256:1a18d52c4d335fbd3f74e2559bc20d6346193a40eef7b85149f51f44f697d182"
+};
 var OPENCODE2 = harnessId("opencode");
+var MODE_CARRYING_HARNESSES = /* @__PURE__ */ new Set([
+  OPENCODE2,
+  harnessId("hermes"),
+  harnessId("pi"),
+  harnessId("omp")
+]);
 var HOOK_COMMAND_PATTERN = /(^|[\\/\s"'])harnesstrim(\.cmd|\.exe)?([\s"']|$)/i;
+var PLUGIN_MODULE_PATTERN2 = /(^|[\\/])harnesstrim\.(ts|js|mjs|cjs|mts|cts)$/i;
 var MANIFEST4 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
   id: HARNESSTRIM2,
@@ -5150,19 +5938,219 @@ var MANIFEST4 = {
     }
   ],
   metrics: {
-    // RFC 0005 §Importer degradation policy: `legacy` is the character-only `TrimEvent` JSONL, and
-    // it is "a supported steady state, not a warning". `native` would need upstream to expose token
-    // counts and native ids, which `0.0.5` does not.
+    // RFC 0005 §Importer degradation policy. `native` since PLAN §15 item 43d: the `0.1.0`
+    // telemetry lines carry a producer `eventId` and nullable token counts, so dedup uses the
+    // native ID and a token count is a token count where one exists. Legacy schema 0 lines
+    // still parse, stay `estimated-local`, and never merge with the native figures.
     source: "jsonl",
-    mode: "legacy",
-    locations: [".harnesstrim/metrics.jsonl", "~/.hermes/harnesstrim-metrics.jsonl"]
+    mode: "native",
+    // PLAN §15 item 25: Hermes has no adapter, tested range or tier, so the home-relative path that
+    // names it is not read. Item 30 readmits it together with the adapter and a matrix row; the
+    // registry assertion in `registries.test.ts` refuses a home-relative location that names a
+    // harness the registry does not know.
+    locations: [".harnesstrim/metrics.jsonl"]
   },
-  delegatedInstallReview: null
+  delegatedInstallReview: {
+    upstreamVersion: "0.0.7",
+    reviewedWriteSet: [
+      ...Object.keys(CLAUDE_ARTIFACT_DIGESTS).map((path) => `.claude/skills/${path}`)
+    ],
+    containmentBoundary: [".claude", "CLAUDE.md"],
+    upstreamUninstallAvailable: true
+  }
 };
-var TESTED_UPSTREAM = "0.0.5";
-var TESTED_VERSIONS = { minimum: TESTED_UPSTREAM, maximum: TESTED_UPSTREAM };
+var TESTED_UPSTREAM = "0.0.7";
+var TESTED_VERSIONS = { minimum: "0.0.5", maximum: TESTED_UPSTREAM };
 function identifiesCommand(command) {
-  return HOOK_COMMAND_PATTERN.test(command);
+  return HOOK_COMMAND_PATTERN.test(command) || PLUGIN_MODULE_PATTERN2.test(command);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function parseHarnessCapabilities(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const record = value;
+  const surfaces = record["surfaces"];
+  const writeSet = record["writeSet"];
+  const narrowing = record["narrowing"];
+  if (!isStringArray(surfaces) || !isStringArray(writeSet) || !Array.isArray(narrowing)) {
+    return null;
+  }
+  const flags = [];
+  for (const item of narrowing) {
+    if (typeof item !== "object" || item === null)
+      return null;
+    const flag = item["flag"];
+    const produces = item["produces"];
+    if (typeof flag !== "string" || typeof produces !== "string")
+      return null;
+    flags.push({ flag, produces });
+  }
+  return {
+    adapter: typeof record["adapter"] === "string" ? record["adapter"] : "",
+    surfaces,
+    writeSet,
+    narrowing: flags
+  };
+}
+function parseCapabilities(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const record = parsed;
+  const version2 = record["version"];
+  const harnesses = record["harnesses"];
+  if (typeof version2 !== "string" || typeof harnesses !== "object" || harnesses === null) {
+    return null;
+  }
+  const entries = {};
+  for (const [harness, value] of Object.entries(harnesses)) {
+    const entry = parseHarnessCapabilities(value);
+    if (entry === null)
+      return null;
+    entries[harness] = entry;
+  }
+  return { version: version2, harnesses: entries };
+}
+async function probeCapabilities(context) {
+  const outcome2 = await context.runner.run({
+    executable: "harnesstrim",
+    args: ["capabilities"],
+    cwd: context.projectRoot,
+    timeoutMs: 2e4
+  });
+  if (outcome2.failure !== null || outcome2.exitCode !== 0) {
+    return {
+      capabilities: null,
+      evidence: [
+        evidence({
+          kind: "absence",
+          source: "harnesstrim capabilities",
+          detail: "did not answer with a machine-readable declaration"
+        })
+      ]
+    };
+  }
+  const capabilities = parseCapabilities(outcome2.stdout);
+  if (capabilities === null) {
+    return {
+      capabilities: null,
+      evidence: [
+        evidence({
+          kind: "version-output",
+          source: "harnesstrim capabilities",
+          path: outcome2.executablePath,
+          detail: "answered, but not with a declaration this build can read"
+        })
+      ]
+    };
+  }
+  return {
+    capabilities,
+    evidence: [
+      evidence({
+        kind: "version-output",
+        source: "harnesstrim capabilities",
+        path: outcome2.executablePath,
+        detail: `declared ${capabilities.version} for ${Object.keys(capabilities.harnesses).join(", ")}`
+      })
+    ]
+  };
+}
+var SURFACE_ANCHORS = {
+  "post-tool-use": "PostToolUse",
+  "tool-execute-after": "tool.execute.after"
+};
+function surfaceMatchesDeclaration(surface, declaration) {
+  const pointAnchor = SURFACE_ANCHORS[declaration.interceptionPoint];
+  if (pointAnchor !== void 0 && !surface.includes(pointAnchor))
+    return false;
+  if (declaration.toolFamily !== EVERY_TOOL_FAMILY && !surface.includes(declaration.toolFamily)) {
+    return false;
+  }
+  return true;
+}
+function writeSetPath(entry) {
+  return entry.replace(/\s*\([^)]*\)\s*$/, "").replaceAll("\\", "/");
+}
+function coveredBy(path, declared) {
+  const base = declared.endsWith("/") ? declared : `${declared}/`;
+  return path === declared || path.startsWith(base);
+}
+function driftWarning(message, remediation) {
+  return diagnostic({
+    severity: "warning",
+    code: "provider-capabilities-drift",
+    subject: "harnesstrim",
+    message,
+    remediation
+  });
+}
+function formatSurface(surface) {
+  return `${surface.toolFamily}/${surface.interceptionPoint}`;
+}
+function narrowable(capabilities) {
+  if (capabilities === null || capabilities === void 0)
+    return false;
+  const managed = MANIFEST4.harnesses.map((entry) => entry.harness);
+  return managed.every((harness) => {
+    const observed = capabilities.harnesses[harness];
+    return observed !== void 0 && observed.narrowing.length > 0;
+  });
+}
+function writeSetStillReviewed(capabilities, harness) {
+  const review = MANIFEST4.delegatedInstallReview;
+  if (review === null || capabilities === null)
+    return false;
+  const observed = capabilities.harnesses[harness];
+  if (observed === void 0)
+    return false;
+  const declared = observed.writeSet.map(writeSetPath);
+  const boundary = review.containmentBoundary.map(writeSetPath);
+  const everyDeclaredPathContained = declared.every((entry) => boundary.some((prefix) => coveredBy(entry, prefix)));
+  const everyReviewedPathCovered = review.reviewedWriteSet.every((reviewed) => declared.some((entry) => coveredBy(reviewed, entry)));
+  return everyDeclaredPathContained && everyReviewedPathCovered;
+}
+function compareCapabilities(manifest, capabilities) {
+  const warnings = [];
+  for (const declaration of manifest.capabilities) {
+    for (const harness of declaration.harnesses) {
+      const observed = capabilities.harnesses[harness];
+      if (observed === void 0) {
+        warnings.push(driftWarning(`the manifest declares ${declaration.capability} on ${harness}, but \`harnesstrim capabilities\` (${capabilities.version}) lists no ${harness} entry`, `Re-test the ${harness} integration: either the manifest is stale or ${harness} lost its HarnessTrim surface`));
+        continue;
+      }
+      const matched = declaration.surfaces.some((surface) => observed.surfaces.some((entry) => surfaceMatchesDeclaration(entry, surface)));
+      if (!matched) {
+        warnings.push(driftWarning(`the manifest records ${declaration.capability} on ${harness} over ${declaration.surfaces.map(formatSurface).join(", ")}, but \`harnesstrim capabilities\` (${capabilities.version}) reports ${observed.surfaces.length === 0 ? "no surfaces" : observed.surfaces.join(" | ")}`, `Re-test the ${harness} integration and update the manifest declaration`));
+      }
+    }
+  }
+  const review = manifest.delegatedInstallReview;
+  if (review === null)
+    return warnings;
+  const claude = capabilities.harnesses["claude"];
+  if (claude === void 0)
+    return warnings;
+  const declared = claude.writeSet.map(writeSetPath);
+  for (const reviewed of review.reviewedWriteSet) {
+    if (declared.some((entry) => coveredBy(reviewed, entry)))
+      continue;
+    warnings.push(driftWarning(`the reviewed write set records ${reviewed} at ${review.upstreamVersion}, but \`harnesstrim capabilities\` (${capabilities.version}) declares nothing covering it (${declared.length === 0 ? "nothing" : declared.join(", ")})`, `Re-review the write set at the installed version before delegating another install`));
+  }
+  const boundary = review.containmentBoundary.map(writeSetPath);
+  for (const entry of declared) {
+    if (boundary.some((prefix) => coveredBy(entry, prefix)))
+      continue;
+    warnings.push(driftWarning(`\`harnesstrim capabilities\` (${capabilities.version}) declares ${entry} for claude, which sits outside the containment boundary recorded at ${review.upstreamVersion} (${boundary.join(", ")})`, "Re-review the write set: rollback restores the boundary, and a path it does not cover would survive a rollback"));
+  }
+  return warnings;
 }
 function harnessesWiredToHarnessTrim(configs) {
   const wired = /* @__PURE__ */ new Set();
@@ -5245,16 +6233,17 @@ async function probeExecutable(context) {
   };
 }
 function metricsLocations(context) {
-  return [
-    context.fs.join(context.projectRoot, ".harnesstrim", "metrics.jsonl"),
-    context.fs.join(context.paths.home, ".hermes", "harnesstrim-metrics.jsonl")
-  ];
+  return [context.fs.join(context.projectRoot, ".harnesstrim", "metrics.jsonl")];
 }
 async function detect4(context) {
   const probe = await probeExecutable(context);
+  const observed = probe.installed ? await probeCapabilities(context) : null;
   const configured = harnessesWiredToHarnessTrim(context.harnessConfigs);
   const warnings = [];
-  const evidenceItems = [...probe.evidence];
+  const evidenceItems = [...probe.evidence, ...observed?.evidence ?? []];
+  if (observed !== null && observed.capabilities !== null) {
+    warnings.push(...compareCapabilities(MANIFEST4, observed.capabilities));
+  }
   for (const harness of configured) {
     evidenceItems.push(evidence({
       kind: "config-entry",
@@ -5292,6 +6281,10 @@ async function detect4(context) {
     // circumstantial: PLAN §11 says Token Harness never installs it, so every installation it ever
     // sees is the user's.
     managedByTokenHarness: false,
+    // PLAN §15 item 46. Decided by the build in front of us, not by the manifest: a build that
+    // declares narrowing flags for every managed harness can be asked for the narrowed states
+    // §6.1 recorded as unproducible, and one that cannot answer keeps the `0.0.5` verdict.
+    assignable: observed?.capabilities === null ? false : narrowable(observed?.capabilities),
     evidence: evidenceItems,
     warnings
   };
@@ -5313,6 +6306,12 @@ function parseTrimEvent(line) {
   if (typeof ts !== "string" || typeof harness !== "string" || typeof before !== "number" || typeof after !== "number") {
     return null;
   }
+  const schemaVersion = typeof record["schemaVersion"] === "number" ? record["schemaVersion"] : 0;
+  if (schemaVersion > 1)
+    return null;
+  const eventId = schemaVersion === 1 && typeof record["eventId"] === "string" && record["eventId"] !== "" ? record["eventId"] : null;
+  if (schemaVersion === 1 && eventId === null)
+    return null;
   return {
     ts,
     harness,
@@ -5320,6 +6319,11 @@ function parseTrimEvent(line) {
     reducer: typeof record["reducer"] === "string" ? record["reducer"] : null,
     beforeChars: before,
     afterChars: after,
+    schemaVersion,
+    eventId,
+    changed: typeof record["changed"] === "boolean" ? record["changed"] : null,
+    beforeTokens: typeof record["beforeTokens"] === "number" ? record["beforeTokens"] : null,
+    afterTokens: typeof record["afterTokens"] === "number" ? record["afterTokens"] : null,
     ...typeof record["mode"] === "string" ? { mode: record["mode"] } : {}
   };
 }
@@ -5331,16 +6335,18 @@ function toEvent(event, sourceId, ordinal, line, context) {
   const instant = new Date(event.ts);
   if (Number.isNaN(instant.getTime()))
     return null;
+  const native = event.schemaVersion === 1;
   const dryrun = event.mode === "dryrun";
-  const eventId = synthesizeEventId(sourceId, ordinal, line);
+  const eventId = native ? event.eventId : synthesizeEventId(sourceId, ordinal, line);
+  const passThrough = native && event.changed === false;
+  const hasTokens = native && event.beforeTokens !== null && event.afterTokens !== null;
+  const hasUnprovenMode = native && MODE_CARRYING_HARNESSES.has(event.harness) && !hasTokens && !passThrough;
   return {
     schemaVersion: OPTIMIZATION_EVENT_SCHEMA_VERSION,
     eventId,
     timestamp: instant.toISOString(),
     provider: { id: HARNESSTRIM2, version: null },
     context: {
-      // The project the metrics file belongs to, which for the default location is the project it
-      // sits inside.
       projectId: context.projectIdFor(context.projectRoot),
       // Unlike RTK's database, a `TrimEvent` names its harness, so this is read rather than left
       // unknown.
@@ -5353,25 +6359,34 @@ function toEvent(event, sourceId, ordinal, line, context) {
       capability: event.harness === OPENCODE2 ? "tool.output.reduce" : "shell.output.reduce"
     },
     measurement: {
-      class: dryrun ? "counterfactual" : "estimated-local",
+      class: dryrun || hasUnprovenMode ? "counterfactual" : hasTokens ? "exact-local" : "estimated-local",
       beforeChars: event.beforeChars,
       afterChars: event.afterChars,
-      // RFC 0005: "never derived silently". `0.0.5` counts characters and nothing else.
-      beforeTokens: null,
-      afterTokens: null,
+      // RFC 0005: "never derived silently". `0.0.5` counts characters and nothing else; the
+      // `0.1.0` producer's counts are used as they are because a token count is a token count
+      // where one exists.
+      beforeTokens: hasTokens ? event.beforeTokens : null,
+      afterTokens: hasTokens ? event.afterTokens : null,
       tokenizer: null,
       confidenceLow: null,
       confidenceHigh: null
     },
     outcome: {
-      // A dryrun leaves `output.output` untouched, so nothing the model saw changed.
-      changed: !dryrun && event.afterChars !== event.beforeChars,
-      bypassReason: dryrun ? "dryrun" : event.afterChars === event.beforeChars ? "no-reduction-applied" : null,
+      // A dryrun leaves `output.output` untouched; a native line states whether its attempt
+      // actually changed the output. A native line whose mode the envelope cannot carry is
+      // deliberately not asserted as a change: the figure may describe a dryrun, and reporting
+      // `changed: true` would claim the model received fewer bytes than it did.
+      changed: dryrun || hasUnprovenMode ? false : native ? event.changed ?? true : event.afterChars !== event.beforeChars,
+      bypassReason: dryrun ? "dryrun" : (
+        // Same reason value as the diagnostic code for the residual ambiguity: nothing refutes a
+        // dryrun, and nothing proves one, so the bypass is the envelope's own silence.
+        hasUnprovenMode ? "mode-unresolved" : native ? passThrough ? "pass-through" : null : event.afterChars === event.beforeChars ? "no-reduction-applied" : null
+      ),
       originalReference: null,
       latencyMs: null,
       errorCode: null
     },
-    source: { nativeEventId: null, importedAt: context.now() }
+    source: { nativeEventId: native ? eventId : null, importedAt: context.now() }
   };
 }
 async function verify4(context) {
@@ -5412,7 +6427,7 @@ async function verify4(context) {
   checks.push({
     id: "canary-intercepted",
     status: receipt === null ? "not-exercised" : "pass",
-    summary: receipt === null ? "no telemetry file exists, so no interception has been recorded" : `${String(receipt.operations)} reductions recorded, most recently ${receipt.observedAt}`,
+    summary: receipt === null ? "no telemetry file yet, so nothing has been observed" : `${String(receipt.operations)} reductions recorded, most recently ${receipt.observedAt}`,
     // A recorded reduction is the provider witnessing its own interception, which is what `canary`
     // means in RFC 0007's tier table.
     achievedTier: receipt === null ? null : "canary",
@@ -5422,7 +6437,7 @@ async function verify4(context) {
   const agents = context.fs.join(context.projectRoot, "AGENTS.md");
   if (await context.fs.stat(agents) !== null) {
     const text = new TextDecoder().decode(await context.fs.readFile(agents));
-    if (identifiesCommand(text)) {
+    if (HOOK_COMMAND_PATTERN.test(text)) {
       checks.push({
         id: "instruction-path-present",
         status: "info",
@@ -5458,6 +6473,8 @@ async function collectMetrics(context, store) {
   let skipped = 0;
   let lastCursor = null;
   let readAny = false;
+  let sawNative = false;
+  let unprovableModeEvents = 0;
   for (const path of metricsLocations(context)) {
     const stat3 = await context.fs.stat(path);
     if (stat3 === null)
@@ -5508,6 +6525,10 @@ async function collectMetrics(context, store) {
         ordinal += 1;
         continue;
       }
+      if (parsed.schemaVersion === 1)
+        sawNative = true;
+      if (event.outcome.bypassReason === "mode-unresolved")
+        unprovableModeEvents += 1;
       events.push(event);
       lastLine = trimmed;
       ordinal += 1;
@@ -5559,21 +6580,104 @@ 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) {
-  await Promise.resolve();
-  return { providerId: HARNESSTRIM2, desiredState: request.desiredState, actions: [] };
+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("/")),
+    digest
+  }));
+  if (!request.harnesses.some((harness) => harness.id === CLAUDE2)) {
+    return { providerId: HARNESSTRIM2, desiredState: request.desiredState, actions: [] };
+  }
+  if (request.desiredState === "absent") {
+    const actions = expectedArtifacts.map((artifact) => ({
+      kind: "remove-owned-change",
+      id: `harnesstrim-claude-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"],
+      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))}`,
+      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 };
+  }
+  const installed = await probeExecutable(context);
+  if (!installed.installed) {
+    return { providerId: HARNESSTRIM2, desiredState: "configured", actions: [] };
+  }
+  const observed = await probeCapabilities(context);
+  const reviewed = observed.capabilities === null ? installed.version === TESTED_UPSTREAM : writeSetStillReviewed(observed.capabilities, CLAUDE2);
+  if (!reviewed) {
+    return { providerId: HARNESSTRIM2, desiredState: "configured", actions: [] };
+  }
+  const review = MANIFEST4.delegatedInstallReview;
+  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] };
 }
 var harnesstrimAdapter = {
   manifest: MANIFEST4,
@@ -5581,11 +6685,13 @@ var harnesstrimAdapter = {
   identifiesCommand,
   verify: verify4,
   collectMetrics,
-  plan
+  plan,
+  plansWithoutOwnership: true
 };
 
 // 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, "\\.")}`;
 }
@@ -5601,6 +6707,8 @@ function planTargets(context, request) {
     const harness = request.harnesses.find((entry) => entry.id === owned.scope.harness);
     if (harness === void 0)
       continue;
+    if (!HOOK_LIST_HARNESSES.has(harness.id))
+      continue;
     const point = harness.interceptionPoints.find((entry) => entry.scopeId === owned.scope.interceptionPoint);
     if (point === void 0)
       continue;
@@ -5733,11 +6841,11 @@ function installAction(context, manifest) {
       channel.digestAvailable ? "the release artifact carries a digest that will be verified" : "this channel publishes no digest, so the artifact cannot be verified by content"
     ],
     postconditions: ["`rtk --version` reports a version inside the tested range"],
-    // Not `package-inventory`: that promises an inventory-based reversal nothing implements. RFC
-    // 0004 allows rollback only by restoring snapshots, "never by inventing an uninstall command",
-    // and a package is not a file — so an installed package survives a rollback and the executor
-    // says so rather than letting the report imply otherwise.
-    rollbackData: "none",
+    // The declared value the executor now implements (RFC 0009 §Initial delivery order item 1):
+    // the executor captures whatever the channel has installed before the install runs, and a
+    // rollback restores that captured version through the same channel. `none` is left only for
+    // channels this build cannot ask about — there the executor says the package stayed instead.
+    rollbackData: channelCanReportInventory(channel.id) ? "package-inventory" : "none",
     explanation: `Install RTK through ${channel.id}`,
     packageManager: channel.id,
     // The channel's own name for the package, because they differ: `rtk-ai.rtk` on winget and
@@ -5776,6 +6884,7 @@ function buildRtkPlan(input) {
 // packages/adapters/dist/src/providers/rtk.js
 var RTK2 = providerId("rtk");
 var CLAUDE3 = harnessId("claude");
+var OPENCODE3 = harnessId("opencode");
 var MANIFEST5 = {
   schemaVersion: MANIFEST_SCHEMA_VERSION,
   id: RTK2,
@@ -5814,10 +6923,53 @@ var MANIFEST5 = {
         sourceReference: "docs/spikes/2.5-live-verification-log.md",
         upstreamVersion: "0.42.0"
       }
+    },
+    /**
+     * OpenCode, from spike 9.1.
+     *
+     * Separate entries rather than adding `OPENCODE` to the two above, because the surface is not
+     * the same one: RTK reaches Claude Code through a `PreToolUse` hook matching `Bash`, and
+     * OpenCode through a plugin on `tool.execute.before`. A capability entry names one surface
+     * list, and merging these would claim that RTK serves `Bash/pre-tool-use` on OpenCode — a
+     * point OpenCode does not have.
+     *
+     * `shell.command.rewrite` and `shell.output.reduce` again arrive together, for the reason they
+     * do on Claude Code: the plugin calls `rtk rewrite`, and the rewritten command is what filters
+     * its own output. One interception point, two capabilities.
+     */
+    {
+      capability: "shell.command.rewrite",
+      mode: "exclusive",
+      harnesses: [OPENCODE3],
+      // `tool.execute` is the family the harness manifest declares as shell-executing. The plugin
+      // narrows to `tool === "bash" || tool === "shell"` inside that family, which is every shell
+      // route OpenCode exposes — unlike Claude Code on Windows, there is no second one to miss.
+      surfaces: [{ toolFamily: "tool.execute", interceptionPoint: "tool-execute-before" }],
+      evidence: {
+        sourceReference: "docs/spikes/9.1-rtk-opencode-observation-log.md",
+        upstreamVersion: "0.44.0"
+      }
+    },
+    {
+      capability: "shell.output.reduce",
+      mode: "exclusive",
+      harnesses: [OPENCODE3],
+      surfaces: [{ toolFamily: "tool.execute", interceptionPoint: "tool-execute-before" }],
+      evidence: {
+        sourceReference: "docs/spikes/9.1-rtk-opencode-observation-log.md",
+        upstreamVersion: "0.44.0"
+      }
     }
   ],
   platforms: [
-    { os: "windows", wsl: false, supported: true, limitation: null },
+    {
+      os: "windows",
+      wsl: false,
+      supported: true,
+      // Spike 9.1. Named on Windows alone because Windows is where Desktop was run; the same
+      // defect on another platform's Desktop build would be a guess until someone watches it.
+      limitation: "RTK's OpenCode plugin is inert under OpenCode Desktop, which supplies no `$` shell helper to plugins, so the plugin's own guard disables it silently"
+    },
     { os: "linux", wsl: true, supported: true, limitation: null },
     { os: "macos", wsl: false, supported: true, limitation: null },
     { os: "linux", wsl: false, supported: true, limitation: null }
@@ -5827,6 +6979,31 @@ var MANIFEST5 = {
       harness: CLAUDE3,
       testedVersions: { minimum: "2.0.0", maximum: "2.1.212" },
       verificationTier: "canary"
+    },
+    {
+      harness: OPENCODE3,
+      // Spike 9.1 watched interception on the CLI at `1.18.11` and watched it fail on Desktop at
+      // `1.18.14`. The range covers both because both were observed; the failure is a declared
+      // platform limitation below rather than a narrower range, because it is a property of the
+      // host application and not of the OpenCode version — the same 1.18.x plugin loads in both.
+      testedVersions: { minimum: "1.18.11", maximum: "1.18.14" },
+      /**
+       * `config-only`, even though spike 9.1 watched a canary-grade interception here — the counter
+       * moved by exactly the number of shell calls the OpenCode session made.
+       *
+       * A tier is what `verify` can prove on the user's machine, not what a spike proved once on a
+       * clean one. RTK's receipt is its history database, and the `commands` table carries
+       * `timestamp`, token counts, `exec_time_ms`, and `project_path` — no harness column, and no
+       * column standing in for one. The spike could attribute those rows because it ran OpenCode
+       * alone in a scratch directory and read the counter either side; `verify` runs where both
+       * harnesses are wired to the same binary and writing into the same table, and cannot say
+       * which of them a row came from.
+       *
+       * Declaring `canary` here would credit RTK's whole command history to whichever harness the
+       * reader happened to be looking at. Claude Code keeps `canary` because its own hook receipt
+       * is per-harness; this one is provider-wide, and RFC 0007 asks the question per harness.
+       */
+      verificationTier: "config-only"
     }
   ],
   installationChannels: [
@@ -5870,9 +7047,10 @@ var MANIFEST5 = {
   },
   delegatedInstallReview: null
 };
-var TESTED_VERSIONS2 = { minimum: "0.40.0", maximum: "0.42.0" };
+var TESTED_VERSIONS2 = { minimum: "0.40.0", maximum: "0.44.0" };
 var VERSION_PATTERN5 = /(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/;
 var HOOK_COMMAND_PATTERN2 = /(^|[\\/\s"'])rtk(\.exe)?([\s"']|$)/i;
+var PLUGIN_MODULE_PATTERN3 = /(^|[\\/])rtk\.(ts|js|mjs|cjs|mts|cts)$/i;
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5915,7 +7093,7 @@ function parseRtkAnalytics(text) {
 function harnessesWiredToRtk(configs) {
   const wired = /* @__PURE__ */ new Set();
   for (const config of configs) {
-    if (config.commands.some((command) => HOOK_COMMAND_PATTERN2.test(command))) {
+    if (config.commands.some((command) => identifiesCommand2(command))) {
       wired.add(config.harnessId);
     }
   }
@@ -6031,13 +7209,32 @@ async function detect5(context) {
     versionVerdict: version2.verdict,
     configuredHarnesses: configured,
     unmanagedHarnessesConfigured: [],
-    // RFC 0002 §Providers may exceed the managed surface. RTK's manifest covers Claude
-    // Code only, so the qualifier RFC 0006's doctor transcript uses for HarnessTrim does
-    // not apply here.
+    /**
+     * RFC 0002 §Providers may exceed the managed surface.
+     *
+     * The field asks whether this manifest names a harness with no adapter behind it. It names two,
+     * Claude Code and OpenCode, and both are managed — so the qualifier RFC 0006's doctor transcript
+     * uses for HarnessTrim does not apply, and the report says "not configured for any harness"
+     * without hedging.
+     *
+     * `rtk init --agent` separately targets Cursor, Windsurf, Cline, Kilo Code, Antigravity, Kimi,
+     * Pi, Hermes, and Droid. That is RTK exceeding *Token Harness*, not this manifest exceeding the
+     * managed set, and it stays out of the flag: claiming those here would make the resolver
+     * responsible for harnesses this build has no adapter to inspect.
+     */
     supportsUnmanagedHarnesses: false,
     // RFC 0004 §Brownfield adoption: nothing has been applied by Token Harness yet, so
     // every installation it finds is the user's.
     managedByTokenHarness: false,
+    /**
+     * Always, and independent of the observed version.
+     *
+     * RTK's assignment is produced by this build writing the hook itself — `rtk-plan.ts` appends
+     * the entry — so nothing about the installed `rtk` decides whether the state is reachable.
+     * That is the difference from HarnessTrim, whose assignment is produced by *its* installer and
+     * therefore depends on which flags that installer has.
+     */
+    assignable: true,
     evidence: evidenceItems,
     warnings
   };
@@ -6138,17 +7335,17 @@ function rtkDatabasePath(context) {
 function cursorGeneration(low) {
   return `rtk-history:low=${String(low ?? 0)}`;
 }
-function toEvent2(row, context) {
-  const id = numberAt(row, "id");
-  const timestamp = stringAt(row, "timestamp");
-  const before = numberAt(row, "input_tokens");
-  const after = numberAt(row, "output_tokens");
+function toEvent2(row2, context) {
+  const id = numberAt(row2, "id");
+  const timestamp = stringAt(row2, "timestamp");
+  const before = numberAt(row2, "input_tokens");
+  const after = numberAt(row2, "output_tokens");
   if (id === null || timestamp === null || before === null || after === null)
     return null;
   const instant = new Date(timestamp);
   if (Number.isNaN(instant.getTime()))
     return null;
-  const projectPath = stringAt(row, "project_path");
+  const projectPath = stringAt(row2, "project_path");
   return {
     schemaVersion: OPTIMIZATION_EVENT_SCHEMA_VERSION,
     // Native, not synthesized: RFC 0005 prefers the upstream identifier when there is one,
@@ -6159,7 +7356,7 @@ function toEvent2(row, 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
@@ -6292,11 +7489,11 @@ async function collectMetrics2(context, store) {
   const events = [];
   let skipped = 0;
   let highest = from;
-  for (const row of batch.rows) {
-    const id = numberAt(row, "id");
+  for (const row2 of batch.rows) {
+    const id = numberAt(row2, "id");
     if (id !== null && id > highest)
       highest = id;
-    const event = toEvent2(row, context);
+    const event = toEvent2(row2, context);
     if (event === null) {
       skipped += 1;
       continue;
@@ -6349,7 +7546,7 @@ async function collectMetrics2(context, store) {
 }
 var SOURCE_LABEL = "rtk history.db (commands)";
 function identifiesCommand2(command) {
-  return HOOK_COMMAND_PATTERN2.test(command);
+  return HOOK_COMMAND_PATTERN2.test(command) || PLUGIN_MODULE_PATTERN3.test(command);
 }
 async function plan2(context, request) {
   const version2 = await readVersion(context);
@@ -6378,7 +7575,6 @@ function listProviderAdapters() {
 
 // apps/cli/dist/src/commands/plan.js
 var DEFAULT_PROFILE = "safe";
-var ASSIGNABLE_PROVIDERS = ["rtk"];
 async function computePlan(context) {
   const diagnostics = [];
   const providerAdapters = listProviderAdapters().filter((adapter) => context.provider === null || adapter.manifest.id === context.provider);
@@ -6405,11 +7601,6 @@ async function computePlan(context) {
       harnessConfigs.push(...inspection.summaries);
     }
   }
-  const providers = providerAdapters.map((adapter) => ({
-    id: adapter.manifest.id,
-    capabilities: adapter.manifest.capabilities,
-    assignable: ASSIGNABLE_PROVIDERS.includes(adapter.manifest.id)
-  }));
   const providerContext = detectionContext === null || context.adapters === null ? null : {
     ...detectionContext,
     harnessConfigs,
@@ -6417,12 +7608,19 @@ async function computePlan(context) {
     localDatabase: context.adapters.localDatabase,
     projectIdFor: context.adapters.projectIdFor
   };
+  const assignable = /* @__PURE__ */ new Map();
   if (providerContext !== null) {
     for (const adapter of providerAdapters) {
       const detection = await adapter.detect(providerContext);
       versions.providers[adapter.manifest.id] = detection.version;
+      assignable.set(adapter.manifest.id, detection.assignable);
     }
   }
+  const providers = providerAdapters.map((adapter) => ({
+    id: adapter.manifest.id,
+    capabilities: adapter.manifest.capabilities,
+    assignable: assignable.get(adapter.manifest.id) ?? false
+  }));
   const resolution = resolveOwnership({
     profile,
     harnesses: present,
@@ -6432,17 +7630,47 @@ 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)
+      if (owned.length === 0 && adapter.plansWithoutOwnership !== true)
         continue;
       const providerPlan = await adapter.plan(providerContext, {
         ownership: owned,
         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 = {
@@ -6500,7 +7728,7 @@ async function computePlan(context) {
       remediation: null
     }));
   }
-  if (resolution.ownership.length > 0 && actions.length === 0) {
+  if (resolution.ownership.length > 0 && actions.length === 0 && blocked.length === 0) {
     diagnostics.push(diagnostic({
       severity: "info",
       code: "already-in-desired-state",
@@ -6508,6 +7736,14 @@ async function computePlan(context) {
       remediation: null
     }));
   }
+  for (const entry of blocked) {
+    diagnostics.push(diagnostic({
+      severity: "error",
+      code: "managed-mutation-blocked",
+      message: `plan refuses managed mutation of ${entry.harness} by ${entry.provider}${entry.providerVersion !== null ? ` at ${entry.providerVersion}` : ""}: ${entry.missing}`,
+      remediation: "Add a compatibility row whose fixture proves this combination, or configure this integration by hand"
+    }));
+  }
   for (const conflict of resolution.conflicts) {
     diagnostics.push(diagnostic({
       severity: "error",
@@ -6516,7 +7752,7 @@ async function computePlan(context) {
       remediation: conflict.remediation
     }));
   }
-  return { report, versions, diagnostics, present, harnessConfigs };
+  return { report, versions, diagnostics, present, harnessConfigs, blocked };
 }
 async function persist(context, computed) {
   if (context.adapters === null || context.stateRoot === null)
@@ -6541,7 +7777,7 @@ async function runPlan(context) {
   const computed = await computePlan(context);
   const persisted = await persist(context, computed);
   const report = { ...computed.report, persisted };
-  const exitCode = report.conflicts.length > 0 ? EXIT_CODES["blocked-by-conflict"] : EXIT_CODES.ok;
+  const exitCode = computed.blocked.length > 0 ? EXIT_CODES["unsupported-environment"] : report.conflicts.length > 0 ? EXIT_CODES["blocked-by-conflict"] : EXIT_CODES.ok;
   return commandResult({
     command: "plan",
     exitCode,
@@ -6612,6 +7848,9 @@ async function runApply(context) {
   const diagnostics = [];
   const computed = await computePlan(context);
   diagnostics.push(...computed.diagnostics);
+  if (computed.blocked.length > 0) {
+    return finish("rejected", EXIT_CODES["unsupported-environment"], emptyReport("rejected"), diagnostics);
+  }
   if (computed.report.conflicts.length > 0) {
     return finish("rejected", EXIT_CODES["blocked-by-conflict"], emptyReport("rejected"), diagnostics);
   }
@@ -6766,10 +8005,40 @@ async function runDoctor(context) {
     projectIdFor: context.adapters?.projectIdFor ?? (() => "p_unattributed")
   })));
   const problemCount = harnesses.filter(isBroken).length + providers.filter(isBroken).length + [...harnesses, ...providers].filter((detection) => detection.versionVerdict === "unknown-newer").length;
+  const rows = context.compatibilityRows ?? COMPATIBILITY_ROWS;
+  const providersWithCoverage = providers.map((detection) => {
+    if (detection.state !== "configured" || detection.configuredHarnesses.length === 0) {
+      return detection;
+    }
+    const uncovered = detection.configuredHarnesses.flatMap((harness) => {
+      const harnessVersion = harnesses.find((candidate) => candidate.harnessId === harness)?.version ?? null;
+      const admission = admitManagedMutation(rows, {
+        provider: detection.providerId,
+        providerVersion: detection.version,
+        harness,
+        harnessVersion,
+        os: context.platform.os,
+        wsl: context.platform.isWsl
+      });
+      if (admission.state === "admitted")
+        return [];
+      return [
+        diagnostic({
+          severity: "warning",
+          code: "no-compatibility-row",
+          message: `no compatibility row covers ${detection.providerId} on ${harness}${detection.version !== null ? ` at ${detection.version}` : ""} \u2014 ${admission.missing}`,
+          remediation: "Add a compatibility row whose fixture proves this combination, or configure this integration by hand"
+        })
+      ];
+    });
+    if (uncovered.length === 0)
+      return detection;
+    return { ...detection, warnings: [...detection.warnings, ...uncovered] };
+  });
   const report = {
     platform: context.platform,
     harnesses,
-    providers,
+    providers: providersWithCoverage,
     problemCount
   };
   return commandResult({
@@ -6861,14 +8130,42 @@ async function runMetrics(context) {
       }
     }
   }
+  const projectId = context.adapters === null ? null : context.adapters.projectIdFor(context.projectRoot);
   const events = [];
   for await (const event of store.query({
     since: window.sinceInstant,
     until: window.untilInstant,
+    ...projectId === null ? {} : { projectId },
     ...context.provider === null ? {} : { providerIds: [context.provider] }
   })) {
     events.push(event);
   }
+  if (projectId === null) {
+    diagnostics.push(diagnostic({
+      severity: "info",
+      code: "metrics-not-project-scoped",
+      message: "This report covers every project in the store: no project identity was available",
+      remediation: null
+    }));
+  } else {
+    let unattributed = 0;
+    for await (const _event of store.query({
+      since: window.sinceInstant,
+      until: window.untilInstant,
+      projectId: UNATTRIBUTED_PROJECT_ID,
+      ...context.provider === null ? {} : { providerIds: [context.provider] }
+    })) {
+      unattributed += 1;
+    }
+    if (unattributed > 0) {
+      diagnostics.push(diagnostic({
+        severity: "info",
+        code: "metrics-unattributed-excluded",
+        message: `${String(unattributed)} operation${unattributed === 1 ? "" : "s"} named no project and are excluded from this report`,
+        remediation: null
+      }));
+    }
+  }
   const report = aggregateEvents({
     events,
     windowStart: window.windowStart,
@@ -6993,7 +8290,12 @@ async function runRollback(context) {
     fs,
     snapshots: built.store,
     journal: built.journal,
-    now: context.now
+    now: context.now,
+    // Package inventories, when the transaction captured any: restoring a package needs the same
+    // process runner the install used. Absent, the rollback reports those packages as not
+    // restored instead of attempting a silent reinstall.
+    runner: context.adapters.runner,
+    cwd: context.projectRoot
   });
   diagnostics.push(...result.diagnostics);
   const report = empty(result.exitCode === 0 ? "rolled-back" : "dirty");
@@ -7115,7 +8417,6 @@ async function runUninstall(context) {
 }
 
 // apps/cli/dist/src/commands/status.js
-var ASSIGNABLE_PROVIDERS2 = ["rtk"];
 async function runStatus(context) {
   const report = {
     platform: context.platform,
@@ -7153,12 +8454,8 @@ async function runStatus(context) {
     configs.push(...inspection.summaries);
   }
   const providerAdapters = listProviderAdapters();
-  const providers = providerAdapters.map((adapter) => ({
-    id: adapter.manifest.id,
-    capabilities: adapter.manifest.capabilities,
-    assignable: ASSIGNABLE_PROVIDERS2.includes(adapter.manifest.id)
-  }));
   const observedVersions = {};
+  const providers = [];
   for (const adapter of providerAdapters) {
     const detection = await adapter.detect({
       ...detectionContext,
@@ -7168,6 +8465,11 @@ async function runStatus(context) {
       projectIdFor: context.adapters.projectIdFor
     });
     observedVersions[adapter.manifest.id] = detection.version;
+    providers.push({
+      id: adapter.manifest.id,
+      capabilities: adapter.manifest.capabilities,
+      assignable: detection.assignable
+    });
   }
   const resolution = resolveOwnership({
     profile: "safe",
@@ -7228,14 +8530,15 @@ function upgradeAction(input) {
     ],
     postconditions: [`${input.packageName} reports ${input.target}`],
     /**
-     * `none`, and the consequence is worth stating where a reviewer sees it.
+     * `package-inventory` where the channel can report what is installed, `none` otherwise.
      *
      * An update replaces a binary. Rolling the transaction back restores files and leaves the new
-     * version in place, so the executor's `install-not-reversible` diagnostic is not boilerplate
-     * here — it is the difference between the machine being restored and the *configuration*
-     * being restored.
+     * version in place, so the executor's receipt is not boilerplate here — it is the difference
+     * between the machine being restored and the *configuration* being restored. With an
+     * inventory-capturing channel the rollback also reinstalls the previous version, and the
+     * receipt says per package whether that reinstall took.
      */
-    rollbackData: "none",
+    rollbackData: channelCanReportInventory(input.channel) ? "package-inventory" : "none",
     explanation: `Update ${input.packageName} from ${input.installed} to ${input.target} through ${input.channel}`,
     packageManager: input.channel,
     packageName: input.packageName,
@@ -7288,7 +8591,7 @@ async function runUpdate(context) {
   for (const adapter of providerAdapters) {
     const detection = await adapter.detect(providerContext);
     const channel = preferredInstallationChannel(adapter.manifest.installationChannels, context.platform.os);
-    const row = {
+    const row2 = {
       providerId: adapter.manifest.id,
       installed: detection.version,
       available: null,
@@ -7297,24 +8600,24 @@ async function runUpdate(context) {
       pin: pins.pins.get(adapter.manifest.id) ?? null
     };
     if (detection.state === "absent") {
-      row.verdict = "not-installed";
-      report.providers.push(row);
+      row2.verdict = "not-installed";
+      report.providers.push(row2);
       continue;
     }
-    if (row.pin !== null) {
-      row.verdict = "pinned";
-      report.providers.push(row);
+    if (row2.pin !== null) {
+      row2.verdict = "pinned";
+      report.providers.push(row2);
       diagnostics.push(diagnostic({
         severity: "info",
         code: "provider-pinned",
-        message: `${adapter.manifest.id} is pinned at ${row.pin}, so no update was planned for it`,
+        message: `${adapter.manifest.id} is pinned at ${row2.pin}, so no update was planned for it`,
         remediation: `Remove it from the pin file to allow updates`
       }));
       continue;
     }
     if (channel === null) {
-      row.verdict = "no-channel";
-      report.providers.push(row);
+      row2.verdict = "no-channel";
+      report.providers.push(row2);
       continue;
     }
     const packageName = channel.packageId ?? adapter.manifest.id;
@@ -7327,21 +8630,21 @@ async function runUpdate(context) {
     diagnostics.push(...query.diagnostics);
     if (query.destination !== null)
       destinations.add(query.destination);
-    row.available = query.version;
+    row2.available = query.version;
     if (query.status !== "found" || query.version === null) {
-      row.verdict = query.status === "unknown" ? "unknown" : "unavailable";
-      report.providers.push(row);
+      row2.verdict = query.status === "unknown" ? "unknown" : "unavailable";
+      report.providers.push(row2);
       continue;
     }
     const installed = detection.version === null ? null : parseSemanticVersion(detection.version);
     const offered = parseSemanticVersion(query.version);
     if (installed === null || offered === null || compareVersions(offered, installed) <= 0) {
-      row.verdict = "current";
-      report.providers.push(row);
+      row2.verdict = "current";
+      report.providers.push(row2);
       continue;
     }
-    row.verdict = "upgradable";
-    report.providers.push(row);
+    row2.verdict = "upgradable";
+    report.providers.push(row2);
     actions.push(upgradeAction({
       providerId: adapter.manifest.id,
       channel: channel.id,
@@ -7508,11 +8811,12 @@ async function runVerify(context) {
       presentHarnesses
     );
     for (const harnessId2 of harnesses) {
+      const declaredTier = adapter.manifest.harnesses.find((entry) => entry.harness === harnessId2)?.verificationTier ?? verification.declaredTier;
       results.push({
         providerId: adapter.manifest.id,
         harnessId: harnessId2,
-        status: statusFor(verification.achievedTier, verification.declaredTier),
-        declaredTier: verification.declaredTier,
+        status: statusFor(verification.achievedTier, declaredTier),
+        declaredTier,
         managedByTokenHarness: MANAGED_PROVIDERS.includes(adapter.manifest.id),
         checks: verification.checks
       });
@@ -7556,11 +8860,52 @@ function statusFor(achieved, declared) {
 }
 
 // apps/cli/dist/src/render/layout.js
+var MAX_WIDTH = 78;
+function wrap(text, indent, width = MAX_WIDTH) {
+  const limit = Math.max(20, width - indent);
+  const words = text.split(/\s+/).filter((word) => word !== "");
+  if (words.length === 0)
+    return [];
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (current === "") {
+      current = word;
+      continue;
+    }
+    if (`${current} ${word}`.length <= limit) {
+      current = `${current} ${word}`;
+      continue;
+    }
+    lines.push(current);
+    current = word;
+  }
+  lines.push(current);
+  const pad = " ".repeat(indent);
+  return lines.map((line, index) => index === 0 ? pad + line : pad + line);
+}
 function column(value, width, minimumGutter = 2) {
   if (value.length >= width)
     return value + " ".repeat(minimumGutter);
   return value.padEnd(width, " ");
 }
+function truncate(value, width) {
+  const characters = [...value];
+  if (characters.length <= width)
+    return value;
+  return `${characters.slice(0, Math.max(1, width - 1)).join("").trimEnd()}\u2026`;
+}
+var COLUMN_SEPARATOR = " - ";
+function row(cells) {
+  const rendered = cells.map(([value, width], index) => index === cells.length - 1 ? value : column(value, width, 0));
+  return rendered.join(COLUMN_SEPARATOR);
+}
+function truncatePath(value, width) {
+  const characters = [...value];
+  if (characters.length <= width)
+    return value;
+  return `\u2026${characters.slice(characters.length - (width - 1)).join("")}`;
+}
 function rightAlign(value, width) {
   return value.padStart(width, " ");
 }
@@ -7639,7 +8984,7 @@ var HEADERS = {
   rollback: "Rollback",
   uninstall: "Uninstall"
 };
-function renderApplyReport(report, _context, command = "apply") {
+function renderApplyReport(report, context, command = "apply") {
   const lines = [];
   const header = [HEADERS[command] ?? "Apply"];
   header.push(report.planId === null ? "no plan" : `plan ${report.planId}`);
@@ -7652,72 +8997,155 @@ function renderApplyReport(report, _context, command = "apply") {
   if (report.results.length > 0) {
     lines.push("Actions");
     for (const [index, result] of report.results.entries()) {
-      lines.push(`  ${String(index + 1)}. ${column(result.kind, KIND_WIDTH)}${column(result.status, STATUS_WIDTH)}${result.path ?? ""}`);
+      lines.push(`  ${String(index + 1)}. ${row([
+        [result.kind, KIND_WIDTH],
+        [result.status, STATUS_WIDTH],
+        // Abbreviated: an absolute Windows path under a long account name ran past 140
+        // characters, and `~/` is both shorter and what every other command shows.
+        [result.path === null ? "" : displayPath(result.path, context.home), 0]
+      ])}`);
     }
     lines.push("");
   }
   if (report.unrestored.length > 0) {
     lines.push("Not restored");
     for (const path of report.unrestored)
-      lines.push(`  ${path}`);
+      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);
 }
 
 // apps/cli/dist/src/render/doctor.js
-var HARNESS_ID_WIDTH = 12;
-var HARNESS_STATE_WIDTH = 12;
-var PROVIDER_ID_WIDTH = 14;
-var PROVIDER_STATE_WIDTH = 14;
-var PROVIDER_VERSION_WIDTH = 8;
-function harnessDetail(detection, context) {
-  if (detection.configPath === null)
-    return "";
-  return displayPath(detection.configPath, context.home);
-}
-function providerNote(detection) {
-  if (detection.state === "broken") {
-    return "installed but not usable";
-  }
-  if (detection.state === "absent" || detection.state === "available") {
-    return "";
-  }
-  if (detection.configuredHarnesses.length === 0) {
-    const qualifier = detection.supportsUnmanagedHarnesses ? "managed harness" : "harness";
-    return `not configured for any ${qualifier}`;
+var NAME_WIDTH = 15;
+var STATE_WIDTH = 12;
+var VERSION_WIDTH = 10;
+var WIRED_WIDTH = 14;
+function harnessState(detection) {
+  switch (detection.state) {
+    case "absent":
+      return "not found";
+    case "detected":
+      return "no hooks";
+    case "configured":
+      return "hooks";
+    case "broken":
+      return "unreadable";
+  }
+}
+function wiredTo(detection) {
+  if (detection.state === "broken")
+    return "cannot run";
+  if (detection.state === "absent")
+    return "not installed";
+  if (detection.configuredHarnesses.length === 0)
+    return "nothing yet";
+  return detection.configuredHarnesses.join(", ");
+}
+function setUpBy(detection) {
+  if (detection.state === "absent" || detection.configuredHarnesses.length === 0)
+    return "\u2014";
+  return detection.managedByTokenHarness ? "this tool" : "you";
+}
+function notes(report) {
+  const lines = [];
+  for (const harness of report.harnesses) {
+    if (harness.state === "broken") {
+      lines.push(`  ${row([
+        [harness.harnessId, NAME_WIDTH - 2],
+        ["configuration could not be read", 0]
+      ])}`);
+    }
+    if (harness.versionVerdict === "unknown-newer") {
+      lines.push(`  ${row([
+        [harness.harnessId, NAME_WIDTH - 2],
+        [`${harness.version ?? ""} is newer than any tested version`, 0]
+      ])}`);
+    }
+  }
+  for (const provider of report.providers) {
+    if (provider.state === "broken") {
+      lines.push(`  ${row([
+        [provider.providerId, NAME_WIDTH - 2],
+        ["installed but could not be run", 0]
+      ])}`);
+    }
+    if (provider.versionVerdict === "unknown-newer") {
+      lines.push(`  ${row([
+        [provider.providerId, NAME_WIDTH - 2],
+        [`${provider.version ?? ""} is newer than any tested version`, 0]
+      ])}`);
+    }
   }
-  const list = detection.configuredHarnesses.join(", ");
-  const adopted = detection.managedByTokenHarness ? "" : " (adopted, not managed)";
-  return `configured for ${list}${adopted}`;
+  return lines;
 }
 function renderDoctorReport(report, context) {
   const lines = [];
   lines.push(`Token Harness ${context.toolVersion} \u2014 ${renderPlatformSummary(report.platform)}, Node ${report.platform.nodeVersion}`);
   lines.push("");
-  lines.push("Harnesses");
+  lines.push(`  ${row([
+    ["HARNESSES", NAME_WIDTH - 2],
+    ["STATE", STATE_WIDTH],
+    ["CONFIG FILE", 0]
+  ])}`);
   if (report.harnesses.length === 0) {
-    lines.push("  no harness adapters registered");
+    lines.push("  none registered");
   } else {
     for (const harness of report.harnesses) {
-      lines.push(`  ${column(harness.harnessId, HARNESS_ID_WIDTH)}${column(harness.state, HARNESS_STATE_WIDTH)}${harnessDetail(harness, context)}`);
+      lines.push(`  ${row([
+        [harness.harnessId, NAME_WIDTH - 2],
+        [harnessState(harness), STATE_WIDTH],
+        [
+          harness.configPath === null ? "" : (
+            // The columns before this one, plus their separators, consume a fixed prefix; the
+            // path gets what is left and is cut from the left so the file name survives.
+            truncatePath(displayPath(harness.configPath, context.home), MAX_WIDTH - (2 + NAME_WIDTH - 2 + 3 + STATE_WIDTH + 3))
+          ),
+          0
+        ]
+      ])}`);
     }
   }
   lines.push("");
-  lines.push("Providers");
+  lines.push(`  ${row([
+    ["PROVIDERS", NAME_WIDTH - 2],
+    ["VERSION", VERSION_WIDTH],
+    ["WIRED TO", WIRED_WIDTH],
+    ["SET UP BY", 0]
+  ])}`);
   if (report.providers.length === 0) {
-    lines.push("  no provider adapters registered");
+    lines.push("  none registered");
   } else {
     for (const provider of report.providers) {
-      lines.push(`  ${column(provider.providerId, PROVIDER_ID_WIDTH)}${column(provider.state, PROVIDER_STATE_WIDTH)}${column(provider.version ?? "", PROVIDER_VERSION_WIDTH)}${providerNote(provider)}`);
+      lines.push(`  ${row([
+        [provider.providerId, NAME_WIDTH - 2],
+        [provider.version ?? "-", VERSION_WIDTH],
+        [wiredTo(provider), WIRED_WIDTH],
+        [setUpBy(provider), 0]
+      ])}`);
     }
   }
+  const notable = notes(report);
+  if (notable.length > 0) {
+    lines.push("");
+    lines.push("NOTES");
+    lines.push(...notable);
+  }
+  const unwired = report.providers.filter((provider) => provider.state !== "absent" && provider.configuredHarnesses.length === 0);
   lines.push("");
-  if (report.problemCount === 0) {
-    lines.push("Nothing is broken. Run `token-harness plan` to see what would change.");
-  } else {
-    lines.push(`${report.problemCount} ${pluralize(report.problemCount, "problem")} found. Fix ${pluralize(report.problemCount, "it", "them")} before running \`token-harness plan\`.`);
+  lines.push("NEXT");
+  const suggestions = report.providers.every((provider) => provider.state === "absent") || unwired.length > 0 ? [["token-harness plan", "see what would change \u2014 writes nothing"]] : [
+    ["token-harness verify", "check the pipeline actually intercepts"],
+    ["token-harness metrics --since 7d", "see what it saved"]
+  ];
+  const commandWidth = Math.max(...suggestions.map(([command]) => command.length));
+  for (const [command, description] of suggestions) {
+    lines.push(`  ${row([
+      [command, commandWidth],
+      [description, 0]
+    ])}`);
   }
   return document(lines);
 }
@@ -7725,11 +9153,10 @@ function renderDoctorReport(report, context) {
 // apps/cli/dist/src/render/metrics.js
 var CLASS_LABEL_WIDTH = 23;
 var FIGURE_BLOCK_GUTTER = 4;
-var PROVIDER_ID_WIDTH2 = 15;
-var PROVIDER_SAVED_WIDTH = 23;
-var PROVIDER_CLASS_WIDTH = 17;
-var PROVIDER_OPERATIONS_WIDTH = 19;
-var PROVIDER_CONTINUATION_INDENT = 2 + PROVIDER_ID_WIDTH2;
+var PROVIDER_ID_WIDTH = 13;
+var PROVIDER_SAVED_WIDTH = 21;
+var PROVIDER_CLASS_WIDTH = 15;
+var PROVIDER_CONTINUATION_INDENT = 2 + PROVIDER_ID_WIDTH;
 var CLASS_LABELS = {
   "exact-local": "Exact local",
   "estimated-local": "Estimated local",
@@ -7737,21 +9164,21 @@ var CLASS_LABELS = {
   "end-to-end-billed": "End-to-end billed"
 };
 function renderClassRows(report) {
-  const byClass = new Map(report.classes.map((row) => [row.class, row]));
-  const ordered = MEASUREMENT_CLASSES.map((id) => byClass.get(id)).filter((row) => row !== void 0);
-  const withFigures = ordered.filter((row) => row.before !== null && row.after !== null);
-  const beforeWidth = Math.max(0, ...withFigures.map((row) => formatCount(row.before).length));
-  const afterWidth = Math.max(0, ...withFigures.map((row) => formatCount(row.after).length));
-  const blocks = ordered.map((row) => {
-    if (row.before === null || row.after === null)
+  const byClass = new Map(report.classes.map((row2) => [row2.class, row2]));
+  const ordered = MEASUREMENT_CLASSES.map((id) => byClass.get(id)).filter((row2) => row2 !== void 0);
+  const withFigures = ordered.filter((row2) => row2.before !== null && row2.after !== null);
+  const beforeWidth = Math.max(0, ...withFigures.map((row2) => formatCount(row2.before).length));
+  const afterWidth = Math.max(0, ...withFigures.map((row2) => formatCount(row2.after).length));
+  const blocks = ordered.map((row2) => {
+    if (row2.before === null || row2.after === null)
       return "";
-    return `${rightAlign(formatCount(row.before), beforeWidth)} -> ${rightAlign(formatCount(row.after), afterWidth)} ${row.unit ?? ""}`;
+    return `${rightAlign(formatCount(row2.before), beforeWidth)} -> ${rightAlign(formatCount(row2.after), afterWidth)} ${row2.unit ?? ""}`;
   });
   const blockWidth = Math.max(0, ...blocks.map((block) => block.length)) + FIGURE_BLOCK_GUTTER;
-  return ordered.map((row, index) => {
-    const label = column(CLASS_LABELS[row.class], CLASS_LABEL_WIDTH);
+  return ordered.map((row2, index) => {
+    const label = column(CLASS_LABELS[row2.class], CLASS_LABEL_WIDTH);
     const block = (blocks[index] ?? "").padEnd(blockWidth, " ");
-    const tail = row.saved === null ? row.note ?? "" : `saved ${formatCount(row.saved)}`;
+    const tail = row2.saved === null ? row2.note ?? "" : `saved ${formatCount(row2.saved)}`;
     return `${label}${block}${tail}`;
   });
 }
@@ -7769,14 +9196,21 @@ function renderMetricsReport(report, _context) {
     lines.push("  no provider reported a measurable saving in this window");
   } else {
     for (const provider of report.providers) {
-      lines.push(`  ${column(provider.providerId, PROVIDER_ID_WIDTH2)}${column(`saved ${formatCount(provider.saved)} ${provider.unit}`, PROVIDER_SAVED_WIDTH)}${column(provider.class, PROVIDER_CLASS_WIDTH)}${column(`${formatCount(provider.operations)} operations`, PROVIDER_OPERATIONS_WIDTH)}${provider.harnesses.join(", ")}`);
-      const notes = [];
+      lines.push(`  ${row([
+        [provider.providerId, PROVIDER_ID_WIDTH],
+        [`saved ${formatCount(provider.saved)} ${provider.unit}`, PROVIDER_SAVED_WIDTH],
+        [provider.class, PROVIDER_CLASS_WIDTH],
+        [`${formatCount(provider.operations)} operations`, 0]
+      ])}`);
+      const notes2 = [];
+      if (provider.harnesses.length > 0)
+        notes2.push(`on ${provider.harnesses.join(", ")}`);
       if (!provider.managedByTokenHarness)
-        notes.push("adopted, not managed");
+        notes2.push("set up by you");
       if (provider.adapterMode !== null)
-        notes.push(`adapter mode ${provider.adapterMode}`);
-      if (notes.length > 0) {
-        lines.push(`${" ".repeat(PROVIDER_CONTINUATION_INDENT)}${notes.join(" \u2014 ")}`);
+        notes2.push(`mode ${provider.adapterMode}`);
+      if (notes2.length > 0) {
+        lines.push(`${" ".repeat(PROVIDER_CONTINUATION_INDENT)}${notes2.join(" \u2014 ")}`);
       }
     }
   }
@@ -7808,8 +9242,8 @@ function renderConflicts(report) {
       lines.push("");
     lines.push(`  ${column("conflict", CONFLICT_LABEL_WIDTH)}${conflict.code}`);
     for (const detail2 of conflict.detail)
-      lines.push(`    ${detail2}`);
-    lines.push(`    Fix: ${conflict.remediation}`);
+      lines.push(...wrap(detail2, 4));
+    lines.push(...wrap(`Fix: ${conflict.remediation}`, 4));
   }
   lines.push("");
   lines.push("No plan was produced.");
@@ -7852,13 +9286,24 @@ function renderPlanReport(report, context) {
   if (report.exclusions.length > 0) {
     lines.push("");
     lines.push("Excluded");
+    const grouped = /* @__PURE__ */ new Map();
     for (const exclusion of report.exclusions) {
-      const [first = "", ...rest] = exclusion.reason;
-      lines.push(`  ${column(exclusion.excluded, EXCLUSION_PROVIDER_WIDTH)}${column(exclusion.scope.capability, EXCLUSION_CAPABILITY_WIDTH)}${first}`);
-      for (const line of rest) {
-        lines.push(`${" ".repeat(EXCLUSION_CONTINUATION_INDENT)}${line}`);
+      const key = `${exclusion.excluded}\0${exclusion.scope.capability}`;
+      const existing = grouped.get(key);
+      if (existing === void 0) {
+        grouped.set(key, {
+          capability: exclusion.scope.capability,
+          harnesses: [exclusion.scope.harness]
+        });
+      } else if (!existing.harnesses.includes(exclusion.scope.harness)) {
+        existing.harnesses.push(exclusion.scope.harness);
       }
     }
+    for (const [key, entry] of grouped) {
+      const provider = key.slice(0, key.indexOf("\0"));
+      lines.push(`  ${column(provider, EXCLUSION_PROVIDER_WIDTH)}${column(entry.capability, EXCLUSION_CAPABILITY_WIDTH)}${entry.harnesses.join(", ")}`);
+      lines.push(...wrap("its installer cannot produce this in isolation, so it is measured but not given the scope", EXCLUSION_CONTINUATION_INDENT));
+    }
   }
   lines.push("");
   lines.push("Actions");
@@ -7934,22 +9379,22 @@ var VERDICT_WIDTH = 15;
 function widthOf(values, floor) {
   return Math.max(floor, ...values.map((value) => value.length + 2));
 }
-function detail(row) {
-  switch (row.verdict) {
+function detail(row2) {
+  switch (row2.verdict) {
     case "upgradable":
-      return `${String(row.installed)} \u2192 ${String(row.available)} via ${String(row.channel)}`;
+      return `${String(row2.installed)} \u2192 ${String(row2.available)} via ${String(row2.channel)}`;
     case "current":
-      return `${String(row.installed)} is the newest ${String(row.channel)} offers`;
+      return `${String(row2.installed)} is the newest ${String(row2.channel)} offers`;
     case "pinned":
-      return `held at ${String(row.pin)} by a pin`;
+      return `held at ${String(row2.pin)} by a pin`;
     case "not-installed":
       return "not installed, so there is nothing to update";
     case "no-channel":
       return "no installation channel on this platform";
     case "unknown":
-      return `${String(row.channel)} answered without a version this build can read`;
+      return `${String(row2.channel)} answered without a version this build can read`;
     case "unavailable":
-      return `${String(row.channel)} could not be asked`;
+      return `${String(row2.channel)} could not be asked`;
   }
 }
 function renderUpdateReport(report, _context) {
@@ -7958,16 +9403,20 @@ function renderUpdateReport(report, _context) {
     lines.push("No provider was inspected.");
     return document(lines);
   }
-  const providerWidth = widthOf(report.providers.map((row) => row.providerId), PROVIDER_WIDTH);
-  const verdictWidth = widthOf(report.providers.map((row) => row.verdict), VERDICT_WIDTH);
-  for (const row of report.providers) {
-    lines.push(`${column(row.providerId, providerWidth)}${column(row.verdict, verdictWidth)}${detail(row)}`);
+  const providerWidth = Math.min(20, widthOf(report.providers.map((entry) => entry.providerId), PROVIDER_WIDTH));
+  const detailStart = providerWidth + 3 + VERDICT_WIDTH + 3;
+  for (const entry of report.providers) {
+    lines.push(truncate(row([
+      [entry.providerId, providerWidth],
+      [entry.verdict, VERDICT_WIDTH],
+      [truncate(detail(entry), MAX_WIDTH - detailStart), 0]
+    ]), MAX_WIDTH));
   }
   if (report.network.length > 0) {
     lines.push("");
     lines.push(`Network: ${report.network.join(", ")}`);
   }
-  const upgradable = report.providers.filter((row) => row.verdict === "upgradable").length;
+  const upgradable = report.providers.filter((row2) => row2.verdict === "upgradable").length;
   const execution = report.execution;
   lines.push("");
   if (execution === null || execution.outcome === "nothing-to-do") {
@@ -7983,33 +9432,34 @@ function renderUpdateReport(report, _context) {
 }
 
 // apps/cli/dist/src/render/verify.js
-var CHECK_STATUS_WIDTH = 6;
-var CHECK_ID_WIDTH = 27;
-function statusWidth(report) {
-  const longest = Math.max(0, ...report.results.flatMap((result) => result.checks.map((check) => check.status.length)));
-  return Math.max(CHECK_STATUS_WIDTH, longest + 2);
+var STATUS_WIDTH2 = 16;
+var CHECK_WIDTH = 12;
+function shortCheck(id) {
+  return truncate(id.replace(/-resolves$|-registered$|-intercepted$/, ""), CHECK_WIDTH);
 }
 function renderVerifyReport(report, _context) {
   const lines = [];
-  const width = statusWidth(report);
-  lines.push(report.receiptId === null || report.appliedAt === null ? "No receipt \u2014 verifying the live configuration" : `Receipt ${report.receiptId} \u2014 applied ${report.appliedAt}`);
-  lines.push("");
+  lines.push(report.receiptId === null || report.appliedAt === null ? "No receipt: verifying what is on the machine now" : `Receipt ${report.receiptId} \u2014 applied ${report.appliedAt}`);
   for (const result of report.results) {
-    const header = [result.providerId, result.harnessId];
-    if (!result.managedByTokenHarness)
-      header.push("adopted, not managed");
-    header.push(`declared tier: ${result.declaredTier}`);
-    lines.push(header.join(" \u2014 "));
+    lines.push("");
+    lines.push(`${result.providerId} on ${result.harnessId} \u2014 set up by ${result.managedByTokenHarness ? "this tool" : "you"}, tier ${result.declaredTier}`);
     for (const check of result.checks) {
-      lines.push(`  ${column(check.status, width)}${column(check.id, CHECK_ID_WIDTH)}${check.summary}`);
+      const indent = 2 + CHECK_WIDTH + 3 + STATUS_WIDTH2 + 3;
+      const wrapped = wrap(check.summary, indent);
+      lines.push(`  ${row([
+        [shortCheck(check.id), CHECK_WIDTH],
+        [check.status, STATUS_WIDTH2],
+        [(wrapped[0] ?? "").trimStart(), 0]
+      ])}`);
+      lines.push(...wrapped.slice(1));
     }
   }
   lines.push("");
   if (report.healthyAtDeclaredTier) {
-    lines.push("Pipeline healthy at the declared tier for every provider.");
+    lines.push("Healthy at the declared tier for every provider.");
   } else {
     const failures = report.results.flatMap((result) => result.checks).filter((check) => check.status === "fail").length;
-    lines.push(`${failures} ${pluralize(failures, "check")} below the declared tier. The pipeline is not proven.`);
+    lines.push(`${String(failures)} ${pluralize(failures, "check")} below tier. Not proven.`);
   }
   return document(lines);
 }
@@ -8053,27 +9503,37 @@ function renderHuman(result, context) {
 }
 
 // apps/cli/dist/src/usage.js
-var ROOT_USAGE = `token-harness \u2014 one control plane for token-efficient coding agents
+var ROOT_USAGE = `token-harness \u2014 set up and measure token-saving tools for coding agents
+
+First time here
+  1  token-harness doctor        what is on this machine        writes nothing
+  2  token-harness plan          what would change              writes nothing
+  3  token-harness apply --yes   make those changes             WRITES
+  4  token-harness verify        is it actually intercepting    writes nothing
+  5  token-harness metrics       what it saved                  writes nothing
+
+  Steps 1 and 2 are safe to run right now. Nothing changes until step 3.
 
 Usage
   token-harness <command> [flags]
+  token-harness help <command>
 
-Commands
-  apply       Execute a plan inside a reversible transaction
-  doctor      Report detected harnesses and providers
-  metrics     Import provider records and report savings by measurement class
-  plan        Compute a dry-run plan; nothing is changed
+Commands, in the order you would use them
+  doctor      What is installed, what is wired up, what is worth knowing
+  plan        Compute what would change, file by file. Changes nothing
+  apply       Run that plan inside a transaction that can be rolled back
+  verify      Check the pipeline actually intercepts, at its declared tier
+  metrics     Report what was saved, labelled with how it was measured
   status      Report applied pipelines, drift, and importer modes
-  verify      Check that an integration actually intercepts, at its declared tier
-  rollback    Restore the files a transaction changed, as they were before it
-  uninstall   Remove what Token Harness owns, leaving everything else
-  update      Update the installed providers to what their channel offers
+  update      Update installed providers to what their channel offers
+  rollback    Restore the files a transaction changed, as they were before
+  uninstall   Remove what Token Harness set up, leaving everything else
 
 Flags
   --json               Emit one machine-readable envelope on stdout
   --harness <id>       Restrict the operation to one harness
   --provider <id>      Restrict the operation to one provider
-  --project <dir>      Operate on that project instead of the current directory
+  --project <dir>      Use that project instead of the current directory
   --since <window>     Report from this point: a duration like 7d, or a date
   --until <window>     Report up to this point; defaults to now
   --plan <id>          Apply a previously computed plan by id
@@ -8081,8 +9541,8 @@ Flags
   --version            Print the version and exit 0
   --help               Print usage and exit 0
 
-Mutating commands are dry-run by default and there is no flag that skips
-planning. Exit codes and the JSON envelope are specified in RFC 0006.`;
+Only apply, update, rollback and uninstall change anything, and none of
+them do without --yes. Exit codes and JSON are specified in RFC 0006.`;
 var COMMAND_USAGE = {
   apply: `token-harness apply \u2014 execute a plan inside a reversible transaction
 
@@ -8221,7 +9681,7 @@ function usageText(topic) {
 }
 
 // apps/cli/dist/src/version.js
-var TOOL_VERSION = "0.1.0";
+var TOOL_VERSION = "0.1.2";
 
 // apps/cli/dist/src/run.js
 var DEFAULT_COMMANDS = {
@@ -8235,12 +9695,31 @@ var DEFAULT_COMMANDS = {
   update: runUpdate,
   verify: runVerify
 };
-function formatDiagnostic(entry) {
-  const lines = [`${entry.severity}  ${entry.code}: ${entry.message}`];
-  if (entry.path !== null)
-    lines.push(`       ${entry.path}`);
-  if (entry.remediation !== null)
-    lines.push(`       Fix: ${entry.remediation}`);
+var SUBJECT_WIDTH = 12;
+function diagnosticLine(entry) {
+  const label = entry.subject ?? entry.code;
+  return truncate(`  ${row([
+    [label, SUBJECT_WIDTH],
+    [entry.message, 0]
+  ])}`, MAX_WIDTH);
+}
+function formatDiagnostics(diagnostics) {
+  const errors = diagnostics.filter((entry) => entry.severity === "error");
+  const warnings = diagnostics.filter((entry) => entry.severity === "warning");
+  if (errors.length === 0 && warnings.length === 0)
+    return "";
+  const lines = [];
+  for (const [title, group] of [
+    ["ERRORS", errors],
+    ["WARNINGS", warnings]
+  ]) {
+    if (group.length === 0)
+      continue;
+    lines.push("");
+    lines.push(title);
+    for (const entry of group)
+      lines.push(diagnosticLine(entry));
+  }
   return `${lines.join("\n")}
 `;
 }
@@ -8282,8 +9761,9 @@ function emit(result, options, renderContext, json) {
   const rendering = renderHuman(result, renderContext);
   if (rendering.report !== "")
     options.streams.out(rendering.report);
-  for (const entry of rendering.stderrDiagnostics)
-    options.streams.err(formatDiagnostic(entry));
+  const diagnostics = formatDiagnostics(rendering.stderrDiagnostics);
+  if (diagnostics !== "")
+    options.streams.err(diagnostics);
   return result.exitCode;
 }
 function emitHelpOrVersion(invocation, options) {
@@ -8378,7 +9858,8 @@ async function run(options) {
     until: invocation.options.until,
     planId: invocation.options.plan,
     confirmed: invocation.options.yes,
-    metrics: options.metrics ?? null
+    metrics: options.metrics ?? null,
+    compatibilityRows: options.compatibilityRows ?? null
   };
   const table = options.commands ?? DEFAULT_COMMANDS;
   let result;