@massu/core 1.13.0 → 1.14.0

package/dist/hooks/user-prompt.js

@@ -1049,6 +1049,45 @@ function initMemorySchema(db) {
     CREATE INDEX IF NOT EXISTS idx_so_file ON shared_observations(file_path);
     CREATE INDEX IF NOT EXISTS idx_so_module ON shared_observations(module);
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS team_promotion_outbound (
+      prompt_hash TEXT PRIMARY KEY,
+      destination TEXT NOT NULL,
+      draft_text TEXT NOT NULL,
+      score REAL,
+      signals_json TEXT NOT NULL DEFAULT '[]',
+      content_hash TEXT NOT NULL,
+      -- PA3-004 (Phase 3 Stream A): hardened-destination publish carries the
+      -- publisher's review attestation so the server CHECK (hardened rows need a
+      -- review_attestation) is satisfiable. hardened=0 for the Phase-2 rows.
+      hardened INTEGER NOT NULL DEFAULT 0,
+      review_attestation_json TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE TABLE IF NOT EXISTS team_revocation_outbound (
+      prompt_hash TEXT PRIMARY KEY,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS rule_promotion_events_outbound (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt_hash TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      metadata_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_rpe_outbound_created ON rule_promotion_events_outbound(created_at);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS analytics_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_type TEXT NOT NULL,
+      event_data TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_analytics_events_type ON analytics_events(event_type);
+  `);
   db.exec(`
     CREATE TABLE IF NOT EXISTS knowledge_conflicts (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1129,6 +1168,13 @@ function initMemorySchema(db) {
       `ALTER TABLE license_cache ADD COLUMN signed_payload_json TEXT NOT NULL DEFAULT ''`
     );
   }
+  const outboundCols = db.prepare(`PRAGMA table_info(team_promotion_outbound)`).all();
+  if (!outboundCols.some((c) => c.name === "hardened")) {
+    db.exec(`ALTER TABLE team_promotion_outbound ADD COLUMN hardened INTEGER NOT NULL DEFAULT 0`);
+  }
+  if (!outboundCols.some((c) => c.name === "review_attestation_json")) {
+    db.exec(`ALTER TABLE team_promotion_outbound ADD COLUMN review_attestation_json TEXT`);
+  }
   db.exec(`
     CREATE TABLE IF NOT EXISTS failure_classes (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1149,6 +1195,28 @@ function initMemorySchema(db) {
     CREATE INDEX IF NOT EXISTS idx_fc_needs_review ON failure_classes(needs_review);
   `);
 }
+var FUNNEL_EVENT_OUTBOX_CAP = 2e4;
+function enqueueRulePromotionEvent(db, ev) {
+  try {
+    db.prepare(`
+      INSERT INTO rule_promotion_events_outbound
+        (prompt_hash, event_type, metadata_json, created_at)
+      VALUES (?, ?, ?, ?)
+    `).run(
+      ev.prompt_hash,
+      ev.event_type,
+      JSON.stringify(ev.metadata ?? {}),
+      ev.created_at
+    );
+    db.prepare(`
+      DELETE FROM rule_promotion_events_outbound
+      WHERE id NOT IN (
+        SELECT id FROM rule_promotion_events_outbound ORDER BY id DESC LIMIT ?
+      )
+    `).run(FUNNEL_EVENT_OUTBOX_CAP);
+  } catch {
+  }
+}
 function assignImportance(type, vrResult) {
   switch (type) {
     case "decision":
@@ -1340,6 +1408,191 @@ function hashPrompt(promptText) {
   return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 
+// src/license.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/security/ed25519-envelope-verifier.ts
+import { createPublicKey, verify as cryptoVerify } from "crypto";
+var SPKI_ED25519_PREFIX = Buffer.from([
+  48,
+  42,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  3,
+  33,
+  0
+]);
+function verifyEd25519SignedEnvelope(key, payload) {
+  if (!key.knownFingerprints.has(key.fingerprintHex)) {
+    return {
+      kind: "error",
+      reason: `Bundled ${key.keyLabel} pubkey fingerprint ${key.fingerprintHex} is not in the trusted allowlist. Possible build-time tamper.`
+    };
+  }
+  const sig = payload._signature;
+  const alg = payload._signature_alg;
+  const payloadKeys = payload._signature_payload_keys;
+  const sigPubkey = payload._signature_pubkey_fingerprint;
+  if (typeof sig !== "string" || sig.length === 0) {
+    return { kind: "missing_signature" };
+  }
+  if (alg !== "ed25519") {
+    return { kind: "error", reason: `Unsupported signature algorithm: ${alg}` };
+  }
+  if (!Array.isArray(payloadKeys) || payloadKeys.length === 0) {
+    return { kind: "error", reason: "Missing _signature_payload_keys" };
+  }
+  if (typeof sigPubkey === "string" && sigPubkey !== key.fingerprintHex) {
+    return { kind: "unknown_pubkey", got: sigPubkey };
+  }
+  const canonicalObj = {};
+  for (const k of payloadKeys) {
+    if (typeof k !== "string") continue;
+    canonicalObj[k] = payload[k];
+  }
+  const canonical = JSON.stringify(canonicalObj, [...payloadKeys].sort());
+  try {
+    const der = Buffer.concat([SPKI_ED25519_PREFIX, Buffer.from(key.pubkeyBytes)]);
+    const pubkey = createPublicKey({ key: der, format: "der", type: "spki" });
+    const ok = cryptoVerify(
+      null,
+      Buffer.from(canonical, "utf-8"),
+      pubkey,
+      Buffer.from(sig, "base64")
+    );
+    return ok ? { kind: "valid" } : { kind: "bad_signature" };
+  } catch (err) {
+    return {
+      kind: "error",
+      reason: `Signature verification threw: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+
+// src/security/license-pubkey.generated.ts
+var LICENSE_PUBKEY_ED25519 = new Uint8Array([39, 136, 108, 146, 85, 233, 119, 252, 223, 226, 123, 155, 234, 168, 200, 150, 36, 249, 174, 6, 130, 146, 125, 196, 136, 224, 202, 150, 53, 228, 114, 15]);
+var LICENSE_PUBKEY_FINGERPRINT_HEX = "18a63d64fdec9e5a368fc45feaa49bed6ced815967e582bc7b8af534f22a9475";
+var KNOWN_LICENSE_PUBKEY_FINGERPRINTS = /* @__PURE__ */ new Set([
+  "18a63d64fdec9e5a368fc45feaa49bed6ced815967e582bc7b8af534f22a9475"
+]);
+
+// src/security/license-response-verifier.ts
+function verifyLicenseResponse(payload) {
+  return verifyEd25519SignedEnvelope(
+    {
+      pubkeyBytes: LICENSE_PUBKEY_ED25519,
+      fingerprintHex: LICENSE_PUBKEY_FINGERPRINT_HEX,
+      knownFingerprints: KNOWN_LICENSE_PUBKEY_FINGERPRINTS,
+      keyLabel: "license"
+    },
+    payload
+  );
+}
+function isLicenseSignatureRequired() {
+  return process.env.MASSU_REQUIRE_SIGNED_LICENSE === "true";
+}
+
+// src/license.ts
+var _warnedLicenseSig = false;
+function warnLicenseSigOnce(reason) {
+  if (_warnedLicenseSig) return;
+  _warnedLicenseSig = true;
+  process.stderr.write(
+    `[massu] WARNING: license-validate response is unsigned or signature invalid (${reason}). Acceptance permitted under transition mode. Operator: provision Supabase Edge Function LICENSE_RESPONSE_SIGNING_PRIVATE_KEY_B64 then set MASSU_REQUIRE_SIGNED_LICENSE=true to enforce strict mode.
+`
+  );
+}
+var TIER_LEVELS = {
+  free: 0,
+  pro: 1,
+  team: 2,
+  enterprise: 3
+};
+function tierLevel(tier) {
+  return TIER_LEVELS[tier] ?? 0;
+}
+var PLAN_TO_TIER_MAP = {
+  free: "free",
+  cloud_pro: "pro",
+  cloud_team: "team",
+  cloud_enterprise: "enterprise"
+};
+var IN_MEMORY_CACHE_TTL_MS = 15 * 60 * 1e3;
+var GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1e3;
+function readTrustedCache(cached) {
+  if (!cached.signed_payload_json) {
+    if (isLicenseSignatureRequired()) return null;
+    warnLicenseSigOnce("cache_unsigned_transition");
+    return {
+      tier: cached.tier,
+      validUntil: cached.valid_until,
+      features: JSON.parse(cached.features || "[]")
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(cached.signed_payload_json);
+  } catch {
+    return null;
+  }
+  const result = verifyLicenseResponse(parsed);
+  if (result.kind !== "valid") return null;
+  const verifiedPlan = typeof parsed.plan === "string" ? parsed.plan : null;
+  const verifiedTierField = typeof parsed.tier === "string" ? parsed.tier : null;
+  const tier = verifiedPlan ? PLAN_TO_TIER_MAP[verifiedPlan] ?? "free" : verifiedTierField ?? "free";
+  const validUntil = typeof parsed.validUntil === "string" ? parsed.validUntil : "";
+  const features = Array.isArray(parsed.features) ? parsed.features : [];
+  const orgId = typeof parsed.orgId === "string" && parsed.orgId.length > 0 ? parsed.orgId : void 0;
+  return { tier, validUntil, features, orgId };
+}
+function getCachedTierReadOnly(memDb) {
+  const config = getConfig();
+  const apiKey = config.cloud?.apiKey;
+  if (!apiKey) return "free";
+  const ownsDb = !memDb;
+  const db = memDb ?? getMemoryDb();
+  try {
+    const keyHash = createHash2("sha256").update(apiKey).digest("hex");
+    const cached = db.prepare(
+      "SELECT tier, valid_until, last_validated, features, signed_payload_json FROM license_cache WHERE api_key_hash = ?"
+    ).get(keyHash);
+    if (!cached) return "free";
+    const trusted = readTrustedCache(cached);
+    if (!trusted) return "free";
+    const lastValidated = new Date(cached.last_validated);
+    const sevenDaysAgo = new Date(Date.now() - GRACE_PERIOD_MS);
+    if (!(lastValidated > sevenDaysAgo)) return "free";
+    return trusted.tier;
+  } catch {
+    return "free";
+  } finally {
+    if (ownsDb) {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  }
+}
+
+// src/auto-learning-entitlement.ts
+var AUTO_LEARNING_MIN_TIER = "pro";
+function entitledForAutoLearning(tier) {
+  return tierLevel(tier) >= tierLevel(AUTO_LEARNING_MIN_TIER);
+}
+function autoLearningUpgradeMessage(currentTier) {
+  return `Auto-learning (rule-candidate detection + /massu-rule promotion) is a Pro feature. Your tier: ${currentTier.toUpperCase()}. Upgrade at https://massu.ai/pricing`;
+}
+var TEAM_SHARED_PROMOTION_MIN_TIER = "team";
+function entitledForTeamSharedPromotion(tier) {
+  return tierLevel(tier) >= tierLevel(TEAM_SHARED_PROMOTION_MIN_TIER);
+}
+
 // src/hooks/user-prompt.ts
 async function main() {
   try {
@@ -1428,19 +1681,46 @@ async function main() {
         });
         const candidateDir = join(hookInput.cwd, ".massu", "rule-candidates");
         if (scoreResult.emitCandidate) {
-          mkdirSync2(candidateDir, { recursive: true });
-          const promptHash = hashPrompt(prompt);
-          const candidatePath = join(candidateDir, `${promptHash}.json`);
-          if (!existsSync3(candidatePath)) {
-            writeFileSync(candidatePath, JSON.stringify({
-              prompt,
-              prompt_hash: promptHash,
-              score: scoreResult.score,
-              signals: scoreResult.signals,
-              prior_turn_files: priorTurn.files,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              session_id
-            }, null, 2));
+          const cachedTier = getCachedTierReadOnly(db);
+          if (entitledForAutoLearning(cachedTier)) {
+            mkdirSync2(candidateDir, { recursive: true });
+            const promptHash = hashPrompt(prompt);
+            const candidatePath = join(candidateDir, `${promptHash}.json`);
+            if (!existsSync3(candidatePath)) {
+              writeFileSync(candidatePath, JSON.stringify({
+                prompt,
+                prompt_hash: promptHash,
+                score: scoreResult.score,
+                signals: scoreResult.signals,
+                prior_turn_files: priorTurn.files,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                session_id
+              }, null, 2));
+              if (entitledForTeamSharedPromotion(cachedTier)) {
+                enqueueRulePromotionEvent(db, {
+                  prompt_hash: promptHash,
+                  event_type: "proposed",
+                  created_at: (/* @__PURE__ */ new Date()).toISOString(),
+                  metadata: {
+                    score: scoreResult.score,
+                    signal_count: scoreResult.signals.length,
+                    category: categorizePrompt(prompt)
+                  }
+                });
+              }
+            }
+          } else {
+            const nudgePath = join(candidateDir, ".last-tier-nudge");
+            if (!existsSync3(nudgePath)) {
+              mkdirSync2(candidateDir, { recursive: true });
+              process.stderr.write(
+                `
+[RULE CANDIDATE] ${autoLearningUpgradeMessage(cachedTier)}
+
+`
+              );
+              writeFileSync(nudgePath, (/* @__PURE__ */ new Date()).toISOString());
+            }
           }
         }
         if (existsSync3(candidateDir)) {
@@ -1474,7 +1754,9 @@ async function main() {
           const sep = pre && !pre.endsWith("\n") ? "\n" : "";
           writeFileSync(logPath, pre + sep + JSON.stringify({
             session_id,
-            prompt_excerpt: prompt.slice(0, 200),
+            // Security review (plan-2026-05-27): log the prompt HASH, never a
+            // raw prompt excerpt — the failure log must not persist PII/secrets.
+            prompt_hash: hashPrompt(prompt),
             error: candidateErr instanceof Error ? candidateErr.message : String(candidateErr),
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           }) + "\n", "utf-8");

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@massu/core",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "type": "module",
-  "description": "AI Engineering Governance MCP Server - Session memory, knowledge system, feature registry, code intelligence, rule enforcement, tiered tooling (12 free / 73 total), 59 workflow commands, 11 agents, 20+ patterns",
+  "description": "AI Engineering Governance MCP Server - Session memory, knowledge system, feature registry, code intelligence, rule enforcement, tiered tooling (12 free / 73 total), 56 workflow commands, 11 agents, 20+ patterns",
   "main": "./dist/cli.js",
   "types": "./dist/adapter.d.ts",
   "exports": {
@@ -29,7 +29,7 @@
     "build:bundle-adapters": "tsx scripts/bundle-adapters.ts",
     "build:cli": "esbuild --bundle --platform=node --format=esm --outfile=dist/cli.js src/cli.ts --external:better-sqlite3 --external:yaml --external:zod --external:chokidar --external:proper-lockfile --external:fsevents --external:web-tree-sitter --external:tweetnacl --external:tar --external:smol-toml --external:vscode-languageserver-protocol --external:@massu/adapter-rails --external:@massu/adapter-spring --banner:js='#!/usr/bin/env node\nimport{createRequire as __cr}from\"module\";const require=__cr(import.meta.url);'",
     "build:hooks": "esbuild --bundle --platform=node --format=esm --outdir=dist/hooks src/hooks/*.ts --external:better-sqlite3 --external:yaml --external:zod --external:chokidar --external:proper-lockfile --external:fsevents --external:web-tree-sitter --external:tweetnacl --external:tar --external:smol-toml --external:vscode-languageserver-protocol --external:@massu/adapter-rails --external:@massu/adapter-spring --banner:js='import{createRequire as __cr}from\"module\";const require=__cr(import.meta.url);'",
-    "prepublishOnly": "bash ../../scripts/prepublish-check.sh && node ../../scripts/bundle-pubkey.mjs && node ../../scripts/bundle-license-pubkey.mjs && cp ../../CHANGELOG.md ./CHANGELOG.md && npm run build",
+    "prepublishOnly": "bash ../../scripts/prepublish-check.sh && node ../../scripts/bundle-pubkey.mjs && node ../../scripts/bundle-license-pubkey.mjs && node ../../scripts/bundle-promotion-pubkey.mjs && cp ../../CHANGELOG.md ./CHANGELOG.md && npm run build",
     "bench:watch": "tsx test/perf/watch-benchmark.ts"
   },
   "dependencies": {

package/commands/massu-autoresearch/references/eval-runner.md

@@ -1,84 +0,0 @@
-# Eval Runner Protocol
-
-## Purpose
-
-Defines how to spawn a subagent to simulate command execution and score the output against the eval checklist.
-
-## Why Subagent-Based Eval?
-
-Claude Code cannot programmatically invoke `/massu-*` commands. The `claude` CLI accepts prompts but doesn't have a `--skill` flag for direct skill invocation. A subagent with the command text injected as instructions is the most practical simulation.
-
-## Eval Execution Steps
-
-### Step 1: Read inputs
-
-Read three files:
-
-1. **Target command file** (current version): `.claude/commands/[command].md` (or `[command]/[command].md` for folder-based)
-2. **Eval checklist** (immutable): `.claude/evals/[command].md`
-3. **Fixture input**: `.claude/evals/fixtures/[command]/input-01.md`
-
-### Step 2: Spawn eval subagent
-
-Use the Agent tool with `subagent_type="general-purpose"` and a prompt structured as:
-
-```
-You are simulating the execution of a Claude Code command. Your job is to produce the output EXACTLY as the command specifies, including all required sections and formatting.
-
-## Command Instructions
-
-[PASTE FULL COMMAND FILE TEXT HERE]
-
-## Input
-
-[PASTE FIXTURE INPUT TEXT HERE]
-
-## Your Task
-
-Execute the command against the input above. Produce the complete output as if you were running the command for real. Include every section the command specifies. Do not skip optional sections — treat everything as required for this simulation.
-
-Do NOT include any meta-commentary about the simulation. Just produce the command output.
-```
-
-### Step 3: Score the output
-
-After the subagent returns its output, score each check from the eval checklist:
-
-For each check in `.claude/evals/[command].md`:
-
-1. Read the check's `pass_condition`
-2. Evaluate the subagent output against that condition
-3. Record `true` (pass) or `false` (fail)
-
-Scoring rules:
-- Checks are binary — no partial credit
-- Section presence checks: the section header must exist AND contain substantive content (not just the header)
-- Count checks (e.g., "at least 3 action items"): count actual items, not placeholders
-- Conditional checks (e.g., "if score >= 40"): evaluate the condition first, then check
-
-### Step 4: Calculate score
-
-```
-score = (passing_checks / total_checks) * 100
-```
-
-### Step 5: Return results
-
-Return to the main loop:
-
-1. `score`: percentage (e.g., 75.0)
-2. `checks`: object mapping check_id to boolean (e.g., `{"has_executive_summary": true, "has_score_table": false, ...}`)
-3. `failing_checks`: list of check_ids that failed
-4. `status`: "success" or "crash" (if subagent errored or output was unparseable)
-
-## Output Containment
-
-The full subagent output is NOT retained in the main agent context. After scoring:
-
-- Discard the full output text
-- Keep only: score, per-check results, failing check names
-- This prevents context window exhaustion during long runs (Karpathy insight #4)
-
-## Crash Handling
-
-If the subagent errors, times out, or produces output that cannot be scored, return `status: "crash"` to the main loop. See `safety-rails.md` for crash retry protocol.

package/commands/massu-autoresearch/references/safety-rails.md

@@ -1,125 +0,0 @@
-# Safety Rails
-
-## Protected Line Patterns
-
-Lines containing ANY of these patterns are READ-ONLY. The agent may add content adjacent to them but MUST NOT modify or delete these lines:
-
-- `CR-` (Canonical Rule references)
-- `VR-` (Verification Requirement references)
-- `NON-NEGOTIABLE`
-- `NEVER` — protected when: (a) at start of line, (b) after bullet/dash (`- NEVER`, `* NEVER`), or (c) in ALL-CAPS imperative context (`NEVER use`, `NEVER edit`, `NEVER import`). NOT protected in lowercase prose (`should never`, `would never`, `can never`).
-- `MANDATORY`
-- `FORBIDDEN`
-- `MUST NOT`
-
-These patterns encode incident-learned safety rules. Modifying them to pass an eval check would optimize the metric while degrading real safety — a Goodhart's Law violation.
-
-### Verification
-
-Before applying any edit, grep the target file for protected patterns in the edit region. If the edit would modify a protected line, reject the edit and try a different approach.
-
----
-
-## Backup Protocol
-
-Before the first iteration of any autoresearch run:
-
-1. Create the backups directory if needed: `.claude/metrics/backups/`
-2. Copy the target file to: `.claude/metrics/backups/[command]-autoresearch-[YYYY-MM-DD-HHmmss].md.bak`
-3. Verify the backup exists and is non-empty
-
-The backup is the ultimate rollback if the entire autoresearch branch needs to be abandoned.
-
----
-
-## Git Branch Protocol
-
-All autoresearch commits go to a dedicated branch:
-
-1. **Resolve target path**: Determine the actual target file path — `.claude/commands/[command].md` for flat commands, `.claude/commands/[command]/[command].md` for folder-based commands. Store as `TARGET_PATH` and use for ALL subsequent git add/checkout operations.
-2. **Create branch**: `git checkout -b autoresearch/[command]-[YYYY-MM-DD]`. If branch already exists (same command, same day), append a numeric suffix: `autoresearch/[command]-[YYYY-MM-DD]-2`, `-3`, etc.
-3. **Commit on KEEP**: `git add [TARGET_PATH] && git commit -m "autoresearch([command]): [1-line summary]"`
-4. **Revert on DISCARD**: `git checkout -- [TARGET_PATH]`
-5. **After run**: User reviews the branch and decides to merge, cherry-pick, or discard
-
-The branch naming convention allows multiple autoresearch runs on different commands without conflict.
-
----
-
-## Cost Tracking
-
-Track estimated token usage per iteration:
-
-- **Eval subagent prompt**: ~target file tokens + eval file tokens + fixture tokens
-- **Eval subagent response**: ~2x fixture tokens (simulated output)
-- **Main agent overhead**: ~500 tokens per iteration (scoring, logging, state)
-
-Rough estimate: each iteration costs ~3x the target file size in tokens.
-
-**Cost cap**: If cumulative estimated token usage exceeds 500K tokens, **stop the loop** and produce the final report. This is a hard backstop regardless of `--no-limit` mode — it is NOT a pause, it is a termination.
-
----
-
-## Tristate Crash Handling
-
-When an eval produces a CRASH result:
-
-1. **Log the crash**: Record in `autoresearch-runs.jsonl` with `"action":"crashed"`
-2. **Do NOT increment** the consecutive reverts counter
-3. **Retry once**: On the retry, use a SIMPLIFIED edit (smaller change, fewer lines modified)
-4. **If retry also crashes**: Log as DISCARD, increment consecutive reverts counter
-5. **Continue the loop** — a single crash does not warrant stopping
-
-Crash accumulation: if `cumulative_crashed >= 5` in a single run, warn that there may be a systemic issue with the eval or fixture.
-
----
-
-## "Think Harder" Graduated Escalation
-
-When consecutive reverts trigger escalation, the edit strategy changes:
-
-### Level 0 (default)
-Normal operation. Target the weakest failing check. Try standard edit types.
-
-### Level 1 (3 consecutive reverts)
-**Switch edit type.** If previous attempts used "add rule", try in this order:
-1. Add a worked example (before/after demonstration)
-2. Restructure the section (reorder for emphasis)
-3. Add a banned anti-pattern
-4. Promote existing requirement higher in the file
-
-### Level 2 (5 consecutive reverts)
-**Full context reload.** Before the next edit:
-1. Re-read the eval checklist from disk (not from memory)
-2. Re-read the target file from disk
-3. Review the changelog of ALL kept changes so far (from `autoresearch-runs.jsonl`)
-4. Identify which failing check has been attempted most without success
-5. Look for TWO previous near-miss approaches and try COMBINING them
-
-### Level 3 (8 consecutive reverts)
-**Radical restructuring.** Try structural changes, not content changes:
-1. Reorder major sections of the target file
-2. Merge two related sections into one focused section
-3. Split an overloaded section into two specific sections
-4. Convert abstract rules into concrete worked examples
-5. Add a decision tree or flowchart for complex logic
-
-### BAIL (10 consecutive reverts)
-**Stagnation exit.** Log: "STAGNATION: 10 consecutive reverts after Level 3 escalation."
-- Revert any pending changes
-- Produce the final report
-- Exit the loop
-- This is the only way CR-37 triggers — after Level 3 has been attempted
-
----
-
-## Output Containment
-
-Eval subagent output is captured and scored, NOT inlined into the main agent context.
-
-The main agent context receives ONLY:
-- Score percentage (e.g., 75.0%)
-- Per-check pass/fail results (e.g., `has_executive_summary: true, has_score_table: false`)
-- Names of failing checks
-
-This is the Karpathy `> run.log 2>&1` pattern adapted for LLM context management.