@chrono-meta/fh-gate 1.4.52 → 1.4.54

package/bin/fh-codex-doctor.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function usage() {
+  process.stdout.write(`Usage:
+  fh-codex-doctor [--root <path>] [--json] [--strict]
+
+Scans FH skills and agents for Codex runtime compatibility drift.
+
+Options:
+  --root <path>  Repository/package root. Defaults to cwd when it looks like FH,
+                 otherwise this package root.
+  --json         Emit machine-readable JSON.
+  --strict       Exit 1 when high-severity drift is found.
+  --help         Show this help.
+`);
+}
+
+function parseArgs(argv) {
+  const out = { root: defaultRoot(), json: false, strict: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      out.help = true;
+    } else if (arg === '--json') {
+      out.json = true;
+    } else if (arg === '--strict') {
+      out.strict = true;
+    } else if (arg === '--root') {
+      i += 1;
+      if (!argv[i]) throw new Error('--root requires a path');
+      out.root = path.resolve(argv[i]);
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+  return out;
+}
+
+function looksLikeFHRoot(dir) {
+  return exists(path.join(dir, 'package.json')) &&
+    exists(path.join(dir, 'plugins')) &&
+    exists(path.join(dir, 'AGENTS.md'));
+}
+
+function defaultRoot() {
+  const cwd = process.cwd();
+  if (looksLikeFHRoot(cwd)) return cwd;
+  return path.resolve(__dirname, '..');
+}
+
+function readText(file) {
+  return fs.readFileSync(file, 'utf8');
+}
+
+function maybeReadText(file) {
+  try {
+    return readText(file);
+  } catch (_err) {
+    return '';
+  }
+}
+
+function exists(file) {
+  try {
+    fs.accessSync(file, fs.constants.F_OK);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+}
+
+function walk(dir, predicate) {
+  const results = [];
+  if (!exists(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walk(p, predicate));
+    } else if (!predicate || predicate(p)) {
+      results.push(p);
+    }
+  }
+  return results;
+}
+
+function rel(root, file) {
+  return path.relative(root, file).split(path.sep).join('/');
+}
+
+function parseFrontmatter(text) {
+  if (!text.startsWith('---\n')) return {};
+  const end = text.indexOf('\n---', 4);
+  if (end === -1) return {};
+  const block = text.slice(4, end).split('\n');
+  const out = {};
+  for (const line of block) {
+    const m = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!m) continue;
+    out[m[1]] = m[2].replace(/^["']|["']$/g, '');
+  }
+  return out;
+}
+
+function extractBacktickNames(line) {
+  const names = [];
+  const re = /`([^`]+)`/g;
+  let m;
+  while ((m = re.exec(line)) !== null) {
+    const value = m[1].trim();
+    if (/^[a-z0-9][a-z0-9-]*$/.test(value)) names.push(value);
+  }
+  return names;
+}
+
+function documentedTiers(root) {
+  const sources = [
+    path.join(root, 'AGENTS.md'),
+  ];
+  const tiers = new Map();
+  const evidence = [];
+  for (const source of sources) {
+    const text = maybeReadText(source);
+    if (!text) continue;
+    const lines = text.split('\n');
+    lines.forEach((line, index) => {
+      const tierMatch = line.match(/\|\s*\*\*(M[123])\b/);
+      if (!tierMatch) return;
+      const tier = tierMatch[1];
+      for (const name of extractBacktickNames(line)) {
+        tiers.set(name, { tier, source: rel(root, source), line: index + 1 });
+        evidence.push({ name, tier, source: rel(root, source), line: index + 1 });
+      }
+    });
+  }
+  return { tiers, evidence };
+}
+
+function compatDocTierMentions(root, skillNames) {
+  const source = path.join(root, 'docs', 'codex-compat.md');
+  const text = maybeReadText(source);
+  const mentions = new Map();
+  if (!text) return mentions;
+  const lines = text.split('\n');
+  lines.forEach((line, index) => {
+    const tierMatch = line.match(/\b(M[123])\b/);
+    if (!tierMatch) return;
+    const tier = tierMatch[1];
+    for (const name of extractBacktickNames(line)) {
+      if (!skillNames.has(name)) continue;
+      if (!mentions.has(name)) mentions.set(name, []);
+      mentions.get(name).push({ tier, source: rel(root, source), line: index + 1 });
+    }
+  });
+  return mentions;
+}
+
+const PRIMITIVES = [
+  {
+    id: 'agent-dispatch',
+    severity: 'adapter',
+    regexes: [/Agent\s*\(/, /\bsubagent_type\b/, /\bAgent View\b/, /\bAgent\b tool\b/, /\bAgent invocation instruction\b/, /\bparallel-Agent dispatch\b/],
+  },
+  {
+    id: 'slash-command',
+    severity: 'adapter',
+    regexes: [/(^|[\s`])\/[a-z][a-z0-9-]+(?=($|[\s`),.;:}]))/m],
+  },
+  {
+    id: 'hook',
+    severity: 'claude-native',
+    regexes: [/\bStop hook\b/i, /\bPostToolUse\b/, /\bSessionStart\b/],
+  },
+  {
+    id: 'model-command',
+    severity: 'claude-native',
+    regexes: [/(^|[\s`])\/model\b/m],
+  },
+];
+
+function scanPrimitives(text) {
+  const hits = [];
+  for (const primitive of PRIMITIVES) {
+    for (const regex of primitive.regexes) {
+      const m = regex.exec(text);
+      if (!m) continue;
+      hits.push({
+        id: primitive.id,
+        severity: primitive.severity,
+        line: text.slice(0, m.index).split('\n').length,
+        match: m[0].trim(),
+      });
+      break;
+    }
+  }
+  return hits;
+}
+
+function classify(docTier, primitives) {
+  const hasClaudeNative = primitives.some((p) => p.severity === 'claude-native');
+  const hasAgentDispatch = primitives.some((p) => p.id === 'agent-dispatch');
+  const hasAdapter = primitives.some((p) => p.severity === 'adapter');
+  if (docTier === 'M1' && (hasClaudeNative || hasAgentDispatch)) return 'tier-drift';
+  if (docTier === 'M1') return 'codex-native';
+  if (docTier === 'M2') return 'adapter-required';
+  if (docTier === 'M3') return 'claude-native';
+  if (hasClaudeNative) return 'claude-native-unclassified';
+  if (hasAdapter) return 'adapter-required-unclassified';
+  return 'codex-native-candidate';
+}
+
+function collectSkills(root) {
+  const skillsRoot = path.join(root, 'plugins');
+  const files = walk(skillsRoot, (p) => path.basename(p) === 'SKILL.md');
+  return files.sort().map((file) => {
+    const text = readText(file);
+    const fm = parseFrontmatter(text);
+    const skillName = fm.name || path.basename(path.dirname(file));
+    return {
+      type: 'skill',
+      name: skillName,
+      path: rel(root, file),
+      frontmatter: fm,
+      primitives: scanPrimitives(text),
+    };
+  });
+}
+
+function collectAgents(root) {
+  const agents = [];
+  for (const plugin of ['fh-meta', 'fh-commons']) {
+    const dir = path.join(root, 'plugins', plugin, 'agents');
+    for (const file of walk(dir, (p) => p.endsWith('.md')).sort()) {
+      const text = readText(file);
+      agents.push({
+        type: 'agent',
+        name: path.basename(file, '.md'),
+        path: rel(root, file),
+        plugin,
+        primitives: scanPrimitives(text),
+      });
+    }
+  }
+  return agents;
+}
+
+function loadAgentCards(root) {
+  const file = path.join(root, '.claude', 'registry', 'agent_cards.json');
+  if (!exists(file)) return { present: false, count: 0 };
+  try {
+    const parsed = JSON.parse(readText(file));
+    const count = Array.isArray(parsed)
+      ? parsed.length
+      : (Array.isArray(parsed.agents) ? parsed.agents.length : (parsed.agent_count || Object.keys(parsed).length));
+    return { present: true, path: rel(root, file), count };
+  } catch (err) {
+    return { present: true, path: rel(root, file), error: err.message, count: 0 };
+  }
+}
+
+function buildReport(root) {
+  const docs = documentedTiers(root);
+  const skills = collectSkills(root).map((skill) => {
+    const doc = docs.tiers.get(skill.name);
+    return {
+      ...skill,
+      documentedTier: doc ? doc.tier : null,
+      tierEvidence: doc || null,
+      codexMode: classify(doc && doc.tier, skill.primitives),
+    };
+  });
+  const agents = collectAgents(root);
+  const skillNames = new Set(skills.map((s) => s.name));
+  const compatMentions = compatDocTierMentions(root, skillNames);
+  const findings = [];
+
+  for (const item of skills) {
+    if (item.documentedTier === 'M1') {
+      const bad = item.primitives.filter((p) => p.severity === 'claude-native' || p.id === 'agent-dispatch');
+      if (bad.length > 0) {
+        findings.push({
+          severity: 'HIGH',
+          code: 'M1_HAS_CLAUDE_NATIVE_PRIMITIVE',
+          path: item.path,
+          message: `${item.name} is documented M1 but contains ${bad.map((p) => p.id).join(', ')}`,
+        });
+      }
+    }
+  }
+
+  for (const entry of docs.evidence) {
+    if (!skillNames.has(entry.name)) {
+      findings.push({
+        severity: 'WARN',
+        code: 'DOC_TIER_REFERENCES_MISSING_SKILL',
+        path: `${entry.source}:${entry.line}`,
+        message: `${entry.name} is listed as ${entry.tier} but no matching SKILL.md was found`,
+      });
+    }
+  }
+
+  for (const item of skills) {
+    const mentions = compatMentions.get(item.name) || [];
+    for (const mention of mentions) {
+      if (item.documentedTier && mention.tier !== item.documentedTier) {
+        findings.push({
+          severity: 'HIGH',
+          code: 'CODEX_COMPAT_TIER_DISAGREES_WITH_AGENTS',
+          path: `${mention.source}:${mention.line}`,
+          message: `${item.name} is ${item.documentedTier} in AGENTS.md but ${mention.tier} in docs/codex-compat.md`,
+        });
+      }
+    }
+  }
+
+  const counts = {
+    skills: skills.length,
+    agents: agents.length,
+    modes: {},
+    tiers: { M1: 0, M2: 0, M3: 0, unclassified: 0 },
+    findings: {
+      HIGH: findings.filter((f) => f.severity === 'HIGH').length,
+      WARN: findings.filter((f) => f.severity === 'WARN').length,
+    },
+  };
+  for (const skill of skills) {
+    counts.modes[skill.codexMode] = (counts.modes[skill.codexMode] || 0) + 1;
+    counts.tiers[skill.documentedTier || 'unclassified'] += 1;
+  }
+
+  return {
+    status: findings.some((f) => f.severity === 'HIGH') ? 'DRIFT' : 'OK',
+    root,
+    counts,
+    agentCards: loadAgentCards(root),
+    findings,
+    skills,
+    agents: agents.map((agent) => ({
+      name: agent.name,
+      path: agent.path,
+      plugin: agent.plugin,
+      codexMode: 'adapter-runnable',
+      note: 'Agents are runnable via fh-run --agent or a runtime-specific dispatch adapter; auto-dispatch is host-specific.',
+    })),
+  };
+}
+
+function printText(report) {
+  const lines = [];
+  lines.push('FH Codex Doctor');
+  lines.push(`Status: ${report.status}`);
+  lines.push(`Root: ${report.root}`);
+  lines.push('');
+  lines.push('Summary');
+  lines.push(`- Skills scanned: ${report.counts.skills}`);
+  lines.push(`- Agents scanned: ${report.counts.agents}`);
+  lines.push(`- Documented tiers: M1=${report.counts.tiers.M1} M2=${report.counts.tiers.M2} M3=${report.counts.tiers.M3} unclassified=${report.counts.tiers.unclassified}`);
+  lines.push(`- Codex modes: ${Object.keys(report.counts.modes).sort().map((k) => `${k}=${report.counts.modes[k]}`).join(' ')}`);
+  if (report.agentCards.present) {
+    lines.push(`- Agent cards: ${report.agentCards.count}${report.agentCards.error ? ` (parse error: ${report.agentCards.error})` : ''}`);
+  } else {
+    lines.push('- Agent cards: missing');
+  }
+  lines.push('');
+  lines.push('Findings');
+  if (report.findings.length === 0) {
+    lines.push('- none');
+  } else {
+    for (const finding of report.findings) {
+      lines.push(`- ${finding.severity} ${finding.code} ${finding.path} :: ${finding.message}`);
+    }
+  }
+  lines.push('');
+  lines.push('Codex Runtime Contract');
+  lines.push('- codex-native: run directly with fh-run/codex exec.');
+  lines.push('- adapter-required: core method can run, but Agent/slash steps need adapter substitution.');
+  lines.push('- claude-native: do not auto-pass; require Claude Code host or explicit dedicated adapter.');
+  lines.push('- unclassified modes are drift signals for future manifest backfill.');
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    process.stderr.write(`ERROR: ${err.message}\n`);
+    usage();
+    process.exit(11);
+  }
+  if (args.help) {
+    usage();
+    return;
+  }
+  const root = args.root;
+  if (!exists(path.join(root, 'package.json'))) {
+    process.stderr.write(`ERROR: root does not look like a package/repo root: ${root}\n`);
+    process.exit(11);
+  }
+  if (!looksLikeFHRoot(root)) {
+    process.stderr.write(`ERROR: root is missing required FH surfaces (AGENTS.md and plugins/): ${root}\n`);
+    process.exit(11);
+  }
+  const report = buildReport(root);
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } else {
+    printText(report);
+  }
+  if (args.strict && report.counts.findings.HIGH > 0) {
+    process.exit(1);
+  }
+}
+
+main();

package/docs/codex-compat.md

@@ -2,7 +2,7 @@
 
 > Status: **beta**. This document is beta-removal condition #2 (see `AGENTS.md` → Codex Compatibility → Beta removal conditions). It lists what works, what breaks, and what to expect when applying forge-harness (FH) methodology through OpenAI Codex (`codex exec`) instead of Claude Code.
 
-FH is a 2-layer system: a **methodology layer** (`tracks/`, `knowledge/`, `SKILL.md` docs) that is model-agnostic, and an **automation layer** (Claude Code hooks, `.claude/agents/`, `/model`, settings.json) that is Claude-native. Codex users run the methodology layer by reading `SKILL.md` files directly; automation steps either run through runtime adapters (`fh-gate`, `fh-run`) or require manual substitution.
+FH is a 2-layer system: a **methodology layer** (`tracks/`, `knowledge/`, `SKILL.md` docs) that is model-agnostic, and an **automation layer** (Claude Code hooks, plugin-channel agents under `plugins/*/agents/`, field-project overrides under `.claude/agents/`, `/model`, settings.json) that is Claude-native. Codex users run the methodology layer by reading `SKILL.md` files directly; automation steps either run through runtime adapters (`fh-gate`, `fh-run`) or require manual substitution.
 
 ## Validated invocation pattern
 
@@ -65,6 +65,20 @@ Resolution order:
 | `--agent plugin:name` | `plugins/plugin/agents/name.md` first |
 | `--unit path` | explicit file path |
 
+### `fh-codex-doctor`
+
+`fh-codex-doctor` is the drift detector for the thin Codex adapter boundary. It reads the canonical
+FH skill/agent files plus the documented M1/M2/M3 tier table, then reports which surfaces are
+Codex-native, adapter-required, Claude-native, or unclassified:
+
+```bash
+npx --package @chrono-meta/fh-gate fh-codex-doctor --strict
+```
+
+Use it before promoting a new Codex automation path. Unknown Claude-native primitives fail closed as
+"manual adaptation required" instead of being treated as compatible by default. When run from an FH
+checkout it scans the current working tree; outside a checkout it scans the installed package.
+
 ### `fh-goal`
 
 Codex has native goal/session features. Use those directly when they fit. `fh-goal` is not a replacement for Codex goal; it is a non-interactive wrapper for "run backend task, then run FH governance on changed files":
@@ -92,7 +106,7 @@ Both ran end-to-end with no Claude-native dependency. The M1 tier claim holds fo
 When `codex exec` runs **inside this repo**, FH's Claude-native git/Stop/PostToolUse hooks attempt to fire and emit `hook: Stop Failed` / `hook: PostToolUse Failed` lines interleaved with output. These are **harmless to the skill result** — the skill's verdict is produced correctly — but they are visible noise. Running from a directory **without** FH's `.claude/settings.json` (the normal Codex-user case) avoids them entirely. Filter with `grep -vE "^hook:"` if needed.
 
 ### 2. M2 skills need manual agent substitution
-M2 skills (`steel-quench`, `harness-doctor`, `context-doctor`, `sim-conductor`, `harvest-loop`) have a core workflow that runs under Codex, but any step that dispatches `Agent(subagent_type=...)` or a slash command must be replaced by `fh-run` or a direct `codex exec` call reading the sub-agent's `SKILL.md`/agent `.md` — same workflow, different runtime (the "M2 adaptation pattern" in `AGENTS.md`). Example: `steel-quench` Waves 1–3 run; the `quench-challenger` agent step becomes `fh-run --agent fh-commons:quench-challenger`.
+M2 skills (`deliberation`, `steel-quench`, `harness-doctor`, `context-doctor`, `sim-conductor`, `harvest-loop`) have a core workflow that runs under Codex, but any step that dispatches `Agent(subagent_type=...)` or a slash command must be replaced by `fh-run` or a direct `codex exec` call reading the sub-agent's `SKILL.md`/agent `.md` — same workflow, different runtime (the "M2 adaptation pattern" in `AGENTS.md`). Example: `steel-quench` Waves 1–3 run; the `quench-challenger` agent step becomes `fh-run --agent fh-commons:quench-challenger`.
 
 ### 3. M3 skills do not run automatically under Codex
 M3 skills (`goal-quench` Phase-3 Stop hook, `hub-cc-pr-reviewer` CC session context, `install-wizard` settings.json write) require Claude-Code-native runtime and are **methodology reference only** under Codex unless a dedicated adapter exists. Use Codex's native goal/session features for goal control, and use `fh-gate` after completion for FH quality gating.
@@ -107,8 +121,8 @@ The sibling pattern for Gemini is `gemini -p "$(cat <skill+artifact>)"`. Outside
 
 | Tier | Under Codex | Action |
 |---|---|---|
-| **M1** | Runs fully | `cat SKILL.md artifact \| codex exec -m gpt-5.5 -` |
-| **M2** | Core runs; agent/slash steps via adapter | Substitute each dispatch with `fh-run` or a direct `codex exec` on the sub-agent's `.md` |
+| **M1** | Runs fully (`token-budget-gate`, `asset-placement-gate`, `phantom-quench`, `deep-clarify`, `convergence-loop`) | `cat SKILL.md artifact \| codex exec -m gpt-5.5 -` |
+| **M2** | Core runs; agent/slash steps via adapter (`deliberation`, `steel-quench`, `harness-doctor`, `context-doctor`, `sim-conductor`, `harvest-loop`) | Substitute each dispatch with `fh-run` or a direct `codex exec` on the sub-agent's `.md` |
 | **M3** | Does not run automatically | Use native Codex session features where available; otherwise read as methodology reference or use a dedicated adapter |
 
 ## Beta removal — remaining (external-blocked)

package/knowledge/shared/harness-core/harness_incubator_doctrine.md

@@ -0,0 +1,139 @@
+# Harness Incubator Doctrine — intent machinization, the nursery, and compose ∪ disrupt
+
+> Crystallized 2026-07-12 from an operator insight session ("the day FH stepped forward").
+> This is the *why* underneath the four pillars in `README.md §What makes it a harness, not a toolbox`.
+> Always-loaded summary: `CLAUDE.md §Identity`. Operating unit: `harness_6axis_framework.md`.
+
+## 1. What a harness is — intent machinization
+
+A harness is a platform that **reads a human's intent and forges it into a machined form**: either
+*AI-salience* (rules and prompts an AI reliably follows) or *deterministic code* (hooks, scripts, gates
+that need no model at all). Building a project IS machinizing human intent; a harness **accelerates and
+amplifies** that machinization.
+
+The trajectory is always the same four steps:
+
+```
+intent (human) → forge into an executable form (AI) → agreement (HITL) → machinery
+```
+
+**Agreement is a load-bearing gate, not a courtesy** — machinizing an unagreed intent hardens the wrong
+thing. The HITL step sits immediately *before* machinization for exactly this reason.
+
+### Trial-and-error relocates; it does not disappear
+
+The harness's payoff is **less trial-and-error on the human side** — the request → feedback → regenerate
+loop is skipped. But the loop is not deleted; it **relocates into the harness**, where agents and
+sidecars run it in parallel. Two gains, not one:
+
+1. Trial-and-error the human **does not perform** → human time drops.
+2. Trial-and-error the harness runs **in parallel** → wall-clock drops versus sequential human retries.
+
+What is freed is not only time but **attention** — and the quality gate (the responsibility-router
+pillar) re-spends that freed attention only where a change is *irreversible*. "Time down + attention
+routed to what matters" is the complete form of harness acceleration, and it is what "quality is the
+lever; speed is the result" cashes out to.
+
+## 2. The scale ladder — tool < star < galaxy
+
+| Unit | What it is |
+|---|---|
+| skill / agent / plugin | a tool |
+| **harness** (field harness) | a *star* — one project's tools, rules, gates, and memory bound into a single working body, purpose-built (e.g. a coding harness specialized for one product domain) |
+| **meta-harness** (FH) | the *galaxy* the stars live in — and a **nursery**, not just a container |
+
+A meta-harness is "a harness for building harnesses." Under a given theme it can machinize anything —
+which is why its unit of work is the harness, not the skill.
+
+## 3. The nursery — FH as field-harness incubator and simulator
+
+FH's dual role:
+
+- **Primary — build and emit**: forge a field harness and release it as an independent, specialized
+  unit. What ships today is the **scaffold + approval machinery** (Full-Harness Mode in
+  `auto_project_mapping.md §6`, gate-compliant field scaffolds); the full simulate-then-emit chamber
+  flow is the *named target*, practiced to date as dogfooding a capability inside FH and then landing
+  it in the field repo.
+- **Contingency — act as the field harness itself**: run the whole of FH (harness-unit, not
+  skill-unit) as a sandbox simulator for a project. Expensive per run — that is the price of a
+  general-purpose chamber.
+
+**Completeness requirement**: a nursery that can birth any star must hold every element. "Everything a
+field-harness simulator needs must be possible inside FH" — multi-model dispatch, tooling, live-surface
+operation, gates. This is an *aspiration that directs capability assembly* (what `goal-quench`'s
+assembly ladder points at), not a claim of current completeness.
+
+**The economics (why expensive-per-run is cheap-in-total):**
+
+```
+Option A: build N field harnesses separately, each doing its own trial-and-error
+          → the same errors are repeated N times; learning is never shared
+Option B: incubate each field project inside the FH chamber
+          → trial-and-error pools in ONE place and compounds (the self-evolving loop)
+          → each next project inherits the previous learning → total trial-and-error shrinks
+```
+
+FH's sandbox unit cost is higher (general-purpose overhead), but total portfolio cost is *expected* to
+be lower — when reuse amortizes the chamber overhead. Honest trade-off: it is expensive *until
+emission*; the emitted harness is specialized and cheap, and the learning stays in FH. **Evidence grade
+(stated honestly)**: this economics is a *design argument plus n=1*, not a measured comparison — the
+counterfactual (building the same capability standalone) was never run, so "cheaper in total" is a
+**named bet**, the same treatment the disrupt path gets in §4(c); residual risk: one-off projects that
+never recur may not amortize. Empirical grounding for the *capability* (not the cost comparison): a
+field QA harness's acts 2–3 arc (2026-07, private) — its live-run capability was forged inside the FH
+chamber, then landed in the field repo.
+
+**Minimal execution skeleton (when the operator accepts simulate-first)**: the procedure is currently
+*judged/ad-hoc*, standardization deferred to a second real occurrence (measured-trigger, per the
+evidence-threshold build discipline): ① open a chamber workspace (a worktree or `tracks/{project}-sim/`
+— never a real project repo); ② scope the run through `goal-quench`'s budget gate (chamber runs are the
+expensive path — cap them); ③ drive the simulation with existing FH assets (dispatch, gates, live
+surfaces as needed); ④ the emit judgment — "the simulation holds" — is a *judged* call paired with the
+run's own mechanical evidence (tests passing, gate verdicts, reproduced flows), decided **with the
+operator (HITL)**; ⑤ on emit, route through Full-Harness Mode / field scaffolds as usual.
+
+**Incubation unit — projects AND features**: incubation applies not only to new projects but to **new
+capabilities of an existing harness**. A field harness's self-development is itself run inside the
+meta-harness chamber first, then transplanted — the nursery forges new layers for existing stars, not
+only new stars. Same economics.
+
+**Simulate-first entry**: when a new project is uncertain, exploratory, or failure-expensive, the
+recommended path is *simulate inside the chamber first, then emit the initial model* — not
+build-immediately. (Wired as a recommendation branch in `CLAUDE.md §Onboarding / Acceleration
+Autopilot`; build-immediately remains correct for clear, small, low-failure-cost projects.)
+
+## 4. Compose ∪ disrupt — two operating modes over other harnesses
+
+| Mode | What | FH mechanism |
+|---|---|---|
+| **Compose** (additive) | cluster leading harnesses, gather their strengths at optimized token cost | sidecar / multi-harness orchestration |
+| **Disrupt** (transformative) | dismantle them into parts, overcome-and-adopt their weak points into FH or a target field harness; self-destruct and reassemble to go where others cannot | **crucible mode** (`crucible_mode.md`) — total-ingest → melt via steel/phantom-quench → identity-bond → reforge; **core invariants never melt** |
+
+Theory anchor (an operator-supplied analogy drawing on Clayton Christensen's disruptive-innovation
+thesis): disruptive technology tends to emerge from re-purposing existing parts
+for unintended uses — crude and inefficient at first, then growing fast along a dimension incumbents
+overlooked. Mapped here: "re-purposed parts" = other harnesses dismantled into components;
+"the overlooked dimension" = the direction others cannot go. Companion criterion,
+**fitness-for-purpose**: equipment that is well-made but would not survive *this* dragon is better
+re-forged from scratch than patched.
+
+Honest boundaries: (a) core invariants (floors, gates, identity) are never melted; (b)
+overcome-and-adopt is curation with license/provenance respect, never wholesale copying; (c) the
+disruptive path *looks inferior early* — running it is a deliberate bet, named as such.
+
+## 5. Sidecar corollary — ride the evolution, don't patch the weak spots
+
+Mechanically patching each frontier model's current weaknesses produces scaffolding that dies as models
+improve (the weakness itself disappears). FH's sidecar layer is therefore built to **co-evolve**: shed
+what the substrate now does natively (`feedback: frontier substrate self-adaptation`), absorb what it
+ships next, and use cross-family decorrelation as *today's* trust lever (composition beats a single
+model's ceiling — see `multi_model_sidecar_strategy.md`). Capability is the model's; assembly, trust,
+and evolution are the harness's.
+
+## Done When (doctrine doc — reference asset)
+
+- The four-pillar README section, `CLAUDE.md §Identity`, and this doc tell one consistent story
+  (no contradicting claims). *Check class: judged; pair: contradiction scan on ingest
+  (`sync_push_protocols.md` step 3).*
+- Every mechanism named here points at a real, existing asset (Full-Harness Mode, crucible_mode,
+  goal-quench, multi_model_sidecar_strategy). *Check class: mandatory-pass (phantom scan).*

package/knowledge/shared/harness-core/sonnet_floor_doctrine.md

@@ -33,6 +33,13 @@ markers) — never silently drop a capability.
   → SessionStart hook), the tone salience gap (2026-07-08 → recorded, prompt-layer), the
   card-reconcile blind spot (2026-07-10 → mtime-independent STATUS map in the hook). The doctrine
   is a name for what the fix pattern already was.
+- **The value does not vanish at the top tier — the harness complements the strongest model too**
+  (operator observation, 2026-07-10, same-day measured): a Sonnet blind probe caught a SIGPIPE
+  silent-death defect in a script the top-tier session had just written (5/5 repro), and the new
+  close-chain checker blocked that same top-tier session's card-last violation twice on its first
+  day. Structure-enforcing checks are tier-blind by construction — so the harness raises the floor
+  for weak models *and* guards the ceiling for strong ones. Weak-model benefit is the larger term
+  (H1), top-tier benefit is the existence proof that the harness is not scaffolding-only.
 
 ## The defect class: tier-gated capability
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrono-meta/fh-gate",
-  "version": "1.4.52",
+  "version": "1.4.54",
   "description": "FH runtime adapters — run FH governance, skills, and agents via Claude or Codex with machine-parseable gates.",
   "license": "MIT",
   "keywords": [
@@ -20,10 +20,11 @@
   "bin": {
     "fh-gate": "bin/fh-gate.js",
     "fh-run": "bin/fh-run.js",
-    "fh-goal": "bin/fh-goal.js"
+    "fh-goal": "bin/fh-goal.js",
+    "fh-codex-doctor": "bin/fh-codex-doctor.js"
   },
   "scripts": {
-    "prepare": "chmod +x bin/fh-gate.js bin/fh-run.js bin/fh-goal.js scripts/fh-gate.sh scripts/fh-run.sh scripts/fh-goal.sh",
+    "prepare": "chmod +x bin/fh-gate.js bin/fh-run.js bin/fh-goal.js bin/fh-codex-doctor.js scripts/fh-gate.sh scripts/fh-run.sh scripts/fh-goal.sh",
     "test": "bash scripts/selfcheck.sh",
     "prepublishOnly": "bash scripts/selfcheck.sh && bash scripts/public_surface_scan_files.sh",
     "release": "bash scripts/public_surface_scan_files.sh && npm publish"
@@ -45,10 +46,13 @@
   },
   "files": [
     "AGENTS.md",
+    ".claude-plugin/marketplace.json",
     "CATALOG.md",
     "CHEATSHEET.md",
     "CLAUDE.md",
+    ".claude/registry/agent_cards.json",
     "docs/CONTRIBUTING.md",
+    "bin/fh-codex-doctor.js",
     "bin/fh-gate.js",
     "bin/fh-run.js",
     "bin/fh-goal.js",
@@ -57,13 +61,20 @@
     "scripts/fh-gate.sh",
     "scripts/fh-run.sh",
     "scripts/fh-goal.sh",
+    "scripts/count_check.sh",
     "scripts/selfcheck.sh",
+    "templates/local_fh_context.md",
+    "plugins/fh-meta/.claude-plugin/plugin.json",
     "plugins/fh-meta/skills",
     "plugins/fh-meta/agents",
+    "plugins/fh-commons/.claude-plugin/plugin.json",
     "plugins/fh-commons/skills",
     "plugins/fh-commons/agents",
     "knowledge/shared/harness-core",
     "knowledge/shared/dialogue",
-    "README.md"
+    "README.md",
+    "README.ko.md",
+    "README.zh.md",
+    "README.ja.md"
   ]
 }