@bglocation/tune-context 2.3.1 → 2.5.0

package/cli/managed-block.mjs

@@ -24,3 +24,27 @@ export function upsertManagedBlock(existing, innerBlock) {
   const next = `${existing}${sep}\n${block}\n`;
   return { content: next, changed: true };
 }
+
+/**
+ * The inverse of upsertManagedBlock: drop the block AND its markers, keep every
+ * byte outside them. Used only by the experiment switch (TASK-087) to reach the
+ * `tc off` arm — init never removes the block, it replaces it.
+ *
+ * Deliberately conservative about what it deletes: only the marker span, plus
+ * the blank lines the removal would otherwise leave stacked at the seam. What
+ * the file's owner wrote below the closing marker is what an off arm has to
+ * keep — losing it would be the TASK-082 defect with a different trigger.
+ *
+ * @param {string|null} existing - current file content, or null if there is no file
+ * @returns {{content: string|null, changed: boolean}} content unchanged when there is no block
+ */
+export function removeManagedBlock(existing) {
+  if (existing == null) return { content: null, changed: false };
+  const startIdx = existing.indexOf(START_MARKER);
+  const endIdx = existing.indexOf(END_MARKER);
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) return { content: existing, changed: false };
+  const head = existing.slice(0, startIdx);
+  const tail = existing.slice(endIdx + END_MARKER.length).replace(/^\n+/, '');
+  const next = head.trim() === '' ? tail : `${head.trimEnd()}\n\n${tail}`;
+  return { content: next, changed: next !== existing };
+}

package/cli/verify.mjs

@@ -158,10 +158,19 @@ function freshnessChecks(claudeDir, pkgRoot) {
 
 /**
  * @param {string} [pkgRoot] - installed package root, for the staleness check
+ * @param {{tc: 'on'|'off', rag: 'on'|'off'}} [arm] - the experiment arm currently set
+ *   through `tune-context experiment` (TASK-087), read from the ledger state — NOT
+ *   detected here. Under `tc: 'off'` the doctrine is *supposed* to be absent, so the
+ *   expectations below are inverted rather than dropped: a missing registration is a
+ *   tick, and one that is still there is a RED, because an off arm that is not off
+ *   invalidates the measurement just as surely as a broken install invalidates a
+ *   session. Reporting "broken install" for a correctly disabled doctrine would be
+ *   the EPIC-006 false-red regression, only pointing the other way.
  * @returns {{ok: boolean, checks: {name: string, ok: boolean, detail?: string, unknown?: boolean}[]}}
  */
-export function verify({ claudeDir, userSettingsPath, expectedHookCommands, projectSettingsPath, expectedPermissions, pkgRoot }) {
+export function verify({ claudeDir, userSettingsPath, expectedHookCommands, projectSettingsPath, expectedPermissions, pkgRoot, arm }) {
   const checks = [];
+  const tcOff = arm?.tc === 'off';
 
   // Cross-check, not two independent presence checks. The old code asked
   // "does some command contain the script name?" and, separately, "does the
@@ -175,6 +184,19 @@ export function verify({ claudeDir, userSettingsPath, expectedHookCommands, proj
     const allCommands = entries.flatMap((g) => (g.hooks || []).map((h) => h.command)).filter(Boolean);
     const installedPath = resolve(join(claudeDir, 'hooks', scriptName));
 
+    if (tcOff) {
+      // Same looseness as the switch's own removal rule: any command naming the
+      // script counts, whatever dir it points at. A stricter test here would let
+      // a stray registration keep firing the hook while verify called the arm clean.
+      const still = allCommands.filter((c) => c.includes(scriptName));
+      checks.push({
+        name: `hooks.${event}: ${scriptName} unregistered (experiment arm tc=off)`,
+        ok: still.length === 0,
+        detail: still.length ? `still registered — the off arm is NOT in effect: ${still.join(', ')}` : undefined,
+      });
+      continue;
+    }
+
     // Classify by DESTINATION, not by spelling: a command that resolves to
     // the very file we installed is the CLI registration, whatever its path
     // happens to look like. Without this, PLUGIN_PATH_HINT's loose
@@ -254,7 +276,24 @@ export function verify({ claudeDir, userSettingsPath, expectedHookCommands, proj
     const scriptPath = join(claudeDir, 'hooks', scriptName);
     const exists = existsSync(scriptPath);
     const executable = exists && Boolean(statSync(scriptPath).mode & 0o111);
-    checks.push({ name: `${scriptName} installed + executable`, ok: exists && executable, detail: !exists ? 'missing' : !executable ? 'not executable' : undefined });
+    // Under an off arm a missing script is not a broken install: the switch
+    // parks REGISTRATIONS, never the scripts, so their absence just means the
+    // doctrine was never installed on this machine — which is what the arm asks
+    // for anyway. Reported as `?`, so it neither passes nor turns the arm red
+    // (epic criterion 4). Present-but-not-executable stays red in both arms: the
+    // arm did not cause it, and it breaks the moment the doctrine goes back on.
+    checks.push({
+      name: `${scriptName} installed + executable`,
+      ok: exists && executable,
+      unknown: tcOff && !exists,
+      detail: !exists
+        ? tcOff
+          ? 'not installed — this arm parks hook registrations, not the scripts themselves'
+          : 'missing'
+        : !executable
+          ? 'not executable'
+          : undefined,
+    });
   }
 
   if (projectSettingsPath && expectedPermissions?.length) {
@@ -268,8 +307,16 @@ export function verify({ claudeDir, userSettingsPath, expectedHookCommands, proj
 
   const skillsDir = join(claudeDir, 'skills');
   for (const skill of ['token-efficiency', 'caveman', 'cdd', 'phase-workflow']) {
-    const ok = existsSync(join(skillsDir, skill, 'SKILL.md'));
-    checks.push({ name: `skill ${skill} installed`, ok, detail: ok ? undefined : `missing ${join(skillsDir, skill, 'SKILL.md')}` });
+    const present = existsSync(join(skillsDir, skill, 'SKILL.md'));
+    if (tcOff) {
+      checks.push({
+        name: `skill ${skill} parked (experiment arm tc=off)`,
+        ok: !present,
+        detail: present ? `still installed at ${join(skillsDir, skill)} — the off arm is NOT in effect` : undefined,
+      });
+      continue;
+    }
+    checks.push({ name: `skill ${skill} installed`, ok: present, detail: present ? undefined : `missing ${join(skillsDir, skill, 'SKILL.md')}` });
   }
 
   checks.push(...freshnessChecks(claudeDir, pkgRoot));

package/eval/adoption-report.mjs

@@ -6,9 +6,10 @@
 // levers show adoption, which don't. See tasks/TASK-062.
 //
 // Honest scope (printed in the report too):
-//   • Cost is NOT here. Claude Code exposes token cost only via OTEL
-//     (`claude_code.cost.usage`, needs a collector) — never a hook. This report
-//     measures *behavior* (a proxy), not dollars. OTEL is the opt-in complement.
+//   • Cost is NOT here. This report reads the hook log, which carries no
+//     tokens — it measures *behavior* (a proxy), not dollars. For dollars see
+//     eval/prompt-metrics.mjs + eval/pricing.mjs (TASK-085/086), which price the
+//     transcript. OTEL stays the independent route to Anthropic's own figure.
 //   • caveman can't be measured: it's an output style, not a tool call.
 //   • RAG availability (the `~` line in the verdict) rests on a project's
 //     `.mcp.json` declaring a semantic-search server that predates the sessions
@@ -75,7 +76,7 @@ Options:
   -h, --help     Show this help
 
 The log is written by the adoption-log.mjs PostToolUse hook (installed by
-tune-context). Cost in dollars is NOT here — that needs OTEL (see report footer).
+tune-context). Cost in dollars is NOT here — see eval/prompt-metrics.mjs.
 `.trim();
 
 export function parseLog(text) {
@@ -494,8 +495,9 @@ export function formatReport(a) {
     }
   }
   L.push('');
-  L.push('Cost (dollars) is not measurable from hooks. For hard cost, enable OTEL:');
-  L.push('  CLAUDE_CODE_ENABLE_TELEMETRY=1 + an OTLP collector →');
+  L.push('Cost (dollars) is not in the hook log. Two independent routes to it:');
+  L.push('  eval/prompt-metrics.mjs — prices the transcript, works with hooks OFF too.');
+  L.push('  OTEL: CLAUDE_CODE_ENABLE_TELEMETRY=1 + an OTLP collector →');
   L.push('  metric `claude_code.cost.usage` (direct) / `claude_code.token.usage`.');
   L.push('  caveman (output style) leaves no tool call — not measured here.');
 
@@ -537,6 +539,6 @@ function main() {
   process.stdout.write(`${formatReport(aggregate(records))}\n`);
 }
 
-if (process.argv[1] && process.argv[1].endsWith('adoption-report.mjs')) {
+if (process.argv[1]?.endsWith('adoption-report.mjs')) {
   main();
 }