@dzhechkov/harness-core 0.8.5 → 0.8.10

package/dist/feature-adr-routing.js

@@ -14,8 +14,8 @@
  *
  * The load-bearing property: a model that WRITES code must not also SELF-QE.
  * When `args.models.qe` is unset, the QE stage is auto-routed to the OTHER
- * family than the resolved coder (codex-coder → Claude `opus`; Claude-coder →
- * `codex:<top>:high`, or `opus` if codex is unavailable — never a block).
+ * family than the resolved coder (codex-coder → Claude `sonnet`; Claude-coder →
+ * the Codex-budget cell, or `opus` if codex is unavailable — never a block).
  *
  * DESIGN CONSTRAINT — the Workflow parser is STRICTER than `node --check`
  * (no nested template literals, no inline `cond ? agent() : null` in arrays).
@@ -29,40 +29,27 @@
 /** Blob version stamp read by scripts/gen-loop-blobs.mjs (feature loop-designer, ADR-004) — the
  * ONLY loop-designer change to this canonical file; bump when any blob-exported semantic changes. */
 export const BLOB_VERSION = '1.0.0';
-/**
- * Per-stage reasoning applied under the usage override (LOCKED L-4, arch §4.1 verbatim):
- * design/code/plan stages ⇒ `xhigh`; router/qe/fleet ⇒ `high`. A pure DATA table (not control
- * flow); user-overridable via `env.usageReasoning`. An unknown stage falls back to `'high'`.
- */
-export const OVERRIDE_REASONING = {
-    router: 'high',
-    requirements: 'xhigh',
-    research: 'xhigh',
-    adr: 'xhigh',
-    ideation: 'xhigh',
-    ddd: 'xhigh',
-    architecture: 'xhigh',
-    plan: 'xhigh',
-    code: 'xhigh',
-    qe: 'high',
-    fleet: 'high',
-};
-/**
- * The gpt-5.6-ready TOP codex-id pick — SHARED by the cross-model QE default and the usage
- * override so adding an id to {@link KNOWN_CODEX} (e.g. `gpt-5.7`) retargets BOTH with zero
- * control-flow diff (AC-3). Pinned `CODEX_MODEL` when ≠ `'auto'`; else the last non-`auto` key of
- * `KNOWN_CODEX`.
- */
+export const STAGE_EFFORT = { override: {
+        router: 'medium',
+        requirements: 'medium',
+        research: 'medium',
+        adr: 'high',
+        ideation: 'medium',
+        ddd: 'high',
+        architecture: 'high',
+        plan: 'high',
+        code: 'medium',
+        qe: 'high',
+        fleet: 'medium',
+    } };
+/** One-release compatibility alias for existing public imports. */
+// Frozen (QE round-1 F10): the alias exports the SAME object as the live effort table, so a
+// consumer mutating the compatibility alias would silently mutate shipped routing. Freezing keeps
+// the read-compatibility promise while making any such write throw loudly in strict mode.
+export const OVERRIDE_REASONING = Object.freeze(STAGE_EFFORT.override);
+/** The flagship Codex id, independent of the spellability allowlist's insertion order. */
 export function topCodexId(env) {
-    let top = env.CODEX_MODEL;
-    if (top === 'auto') {
-        const ids = Object.keys(KNOWN_CODEX);
-        for (let i = 0; i < ids.length; i++) {
-            if (ids[i] !== 'auto')
-                top = ids[i] || top;
-        }
-    }
-    return top;
+    return env.CODEX_MODEL !== 'auto' ? env.CODEX_MODEL : CODEX_TIERS.flagship;
 }
 /**
  * The PURE hysteresis core (the load-bearing safety property, AC-1). Given the previous override
@@ -104,10 +91,69 @@ export function decideUsageAction(prevOverride, signal, threshold) {
 // ── Data tables (data-only extensibility — gpt-5.6-ready) ───────────────────
 /** Known codex ids. Adding a new id (e.g. `'gpt-5.7'`) is a DATA-ONLY change. */
 export const KNOWN_CODEX = { auto: 1, 'gpt-5.5': 1, 'gpt-5.6': 1, 'gpt-5.6-luna': 1, 'gpt-5.6-terra': 1, 'gpt-5.6-sol': 1 };
+/**
+ * Capability tiers are routing data, separate from {@link KNOWN_CODEX}'s spellability role.
+ * The allowlist is not an availability check — probe every id before every run
+ * (`codex exec -m <id> "Reply with exactly: OK"`); ids drift in both directions on a
+ * timescale of days (probed 2026-08-18: 3 ids HTTP 400; probed 2026-08-29: all 3 exit 0).
+ */
+export const CODEX_TIERS = {
+    flagship: 'gpt-5.6-sol',
+    workhorse: 'gpt-5.6-terra',
+    'high-volume': 'gpt-5.6-luna',
+};
+export function codexIdForTier(tier, env) {
+    return env.CODEX_MODEL !== 'auto' ? env.CODEX_MODEL : CODEX_TIERS[tier];
+}
+export const BUDGET_PRESETS = {
+    normal: { claude: 'normal', codex: 'normal' },
+    eco: { claude: 'eco', codex: 'eco' },
+    hybrid: { claude: 'eco', codex: 'normal' },
+};
+export function resolveBudgetMode(raw) {
+    if (raw === undefined)
+        return BUDGET_PRESETS.normal;
+    if (typeof raw === 'string') {
+        const preset = BUDGET_PRESETS[raw];
+        if (!preset)
+            throw new RangeError('budget: unknown preset "' + raw + '" — valid: normal|eco|hybrid');
+        return preset;
+    }
+    if (raw && typeof raw === 'object') {
+        const value = raw;
+        for (const key of Object.keys(value)) {
+            if (key !== 'claude' && key !== 'codex') {
+                throw new RangeError('budget: unknown family key "' + key + '" — valid: claude|codex');
+            }
+        }
+        for (const key of ['claude', 'codex']) {
+            const level = value[key];
+            if (level !== undefined && level !== 'normal' && level !== 'eco') {
+                throw new RangeError('budget.' + key + ': unknown level "' + level + '" — valid: normal|eco');
+            }
+        }
+        return {
+            claude: value.claude || 'normal',
+            codex: value.codex || 'normal',
+        };
+    }
+    throw new RangeError('budget: expected a preset name or {claude,codex} object, got ' + typeof raw);
+}
+export function budgetPresetName(axis) {
+    for (const name of ['normal', 'eco', 'hybrid']) {
+        const preset = BUDGET_PRESETS[name];
+        if (preset.claude === axis.claude && preset.codex === axis.codex)
+            return name;
+    }
+    return null;
+}
 /** The Claude model names the Workflow runtime accepts as `agent()` `model`. */
 export const CLAUDE_NAMES = { fable: 1, opus: 1, sonnet: 1, haiku: 1 };
-/** The codex-companion `--effort` vocabulary; a spec's `<reasoning>` is clamped to this (unknown ⇒ 'high'). */
-export const VALID_REASONING = { none: 1, minimal: 1, low: 1, medium: 1, high: 1, xhigh: 1 };
+/**
+ * The codex-companion `--effort` vocabulary. `minimal` remains temporarily for compatibility
+ * until a live companion probe establishes whether it can be retired; `max` is part of GPT-5.6's ladder.
+ */
+export const VALID_REASONING = { none: 1, minimal: 1, low: 1, medium: 1, high: 1, xhigh: 1, max: 1 };
 /**
  * The proven DEFAULT TABLE, applied only when the user opts into routing.
  * `code`/`qe` are `null` SENTINELS: their defaults are DERIVED (the coder knob /
@@ -126,6 +172,68 @@ export const DEFAULT_MODELS = {
     qe: null,
     fleet: 'sonnet',
 };
+/** Four family half-tables; presets compose the Claude and Codex halves independently. */
+export const ROUTING_TABLES = {
+    claude: {
+        claude: {
+            normal: { router: 'sonnet', requirements: 'sonnet', research: 'sonnet', adr: 'fable', ideation: 'sonnet', ddd: 'fable', architecture: 'fable', plan: 'opus', code: 'sonnet', fleet: 'sonnet' },
+            eco: { router: 'sonnet', requirements: 'sonnet', research: 'sonnet', adr: 'opus', ideation: 'sonnet', ddd: 'opus', architecture: 'opus', plan: 'sonnet', code: 'sonnet', fleet: 'sonnet' },
+        },
+        codex: { normal: {}, eco: {} },
+    },
+    codex: {
+        claude: {
+            normal: { router: 'sonnet', qe: 'sonnet', fleet: 'sonnet' },
+            eco: { router: 'sonnet', qe: 'sonnet', fleet: 'sonnet' },
+        },
+        codex: { normal: {}, eco: {} },
+    },
+};
+function codexCell(tier, effort, env) {
+    return 'codex:' + codexIdForTier(tier, env) + ':' + effort;
+}
+export function budgetTable(primary, mode, env) {
+    const claudeHalf = ROUTING_TABLES[primary].claude[mode.claude];
+    let codexHalf;
+    if (primary === 'claude') {
+        const qeSpec = mode.codex === 'normal'
+            ? codexCell('flagship', 'high', env)
+            : codexCell('workhorse', 'medium', env);
+        codexHalf = { ...ROUTING_TABLES.claude.codex[mode.codex], qe: env.codexAvailable === false ? 'opus' : qeSpec };
+    }
+    else {
+        const normal = mode.codex === 'normal';
+        const design = codexCell(normal ? 'flagship' : 'workhorse', normal ? 'high' : 'medium', env);
+        codexHalf = {
+            requirements: design,
+            research: design,
+            adr: design,
+            ideation: design,
+            ddd: design,
+            architecture: design,
+            plan: codexCell(normal ? 'flagship' : 'workhorse', normal ? 'high' : 'low', env),
+            code: codexCell(normal ? 'flagship' : 'workhorse', 'medium', env),
+        };
+    }
+    return { ...claudeHalf, ...codexHalf };
+}
+/** Optional Claude precision review after A-normal's recall-oriented Sonnet QE. */
+export function qePrecisionPassSpec(primary, budget, tier, _env) {
+    if (primary !== 'codex')
+        return null;
+    if (budget.claude !== 'normal')
+        return null;
+    if (tier !== 'L' && tier !== 'XL')
+        return null;
+    return 'opus';
+}
+/** Build/test-time guard for the matrix's load-bearing cross-family property. */
+export function assertCrossFamilyQe(codeSpec, qeSpec) {
+    const fam = (s) => (s && String(s).split(':')[0] === 'codex') ? 'codex' : 'claude';
+    if (fam(codeSpec) === fam(qeSpec)) {
+        throw new Error('cross-family QE violated: code=' + codeSpec + ' qe=' + qeSpec);
+    }
+}
 // ── Pure resolvers (byte-equivalent to the workflow's inline block) ──────────
 /**
  * Turn a compact model SPEC into `agent()` opts.
@@ -157,11 +265,8 @@ export function specToOpts(spec, env) {
             id = env.CODEX_MODEL;
         }
         let reasoning = parts[2] || 'high';
-        // Clamp to the codex-companion --effort vocabulary so a bad token (e.g. `codex:gpt-5.6:banana`)
-        // can't silently reach the runtime as `--effort banana` (QE LOW). Unknown ⇒ 'high'.
         if (!VALID_REASONING[reasoning]) {
-            log('models: unknown reasoning ' + reasoning + ' — using high');
-            reasoning = 'high';
+            throw new RangeError('models: invalid reasoning "' + reasoning + '" — valid: ' + Object.keys(VALID_REASONING).join('|'));
         }
         return { agentType: 'codex:codex-rescue', codexModel: id, _reasoning: reasoning };
     }
@@ -188,34 +293,43 @@ export function resolveCoderSpec(env) {
  * `MODELS.code='codex'` still routes QE to Claude (never codex-self-QE).
  */
 export function coderIsCodex(env) {
-    if (env.CODER === 'codex' || env.CODER === 'codex-fallback')
-        return true;
     const codeSpec = env.MODELS.code;
-    if (codeSpec && String(codeSpec).split(':')[0] === 'codex')
+    if (codeSpec !== undefined && codeSpec !== null)
+        return String(codeSpec).split(':')[0] === 'codex';
+    if (env.CODER === 'codex' || env.CODER === 'codex-fallback')
         return true;
-    return false;
+    return env.primary === 'codex';
 }
 /**
  * The CROSS-MODEL QE default (load-bearing). Called only when `MODELS.qe` is
  * unset. Resolves to the OTHER family than the coder:
- *   - coder is codex  → `'opus'`                       (Claude reviews codex's code)
- *   - coder is Claude → codex-available ? `'codex:<top>:high'` : `'opus'` (never block)
- * `<top>` = `CODEX_MODEL` when pinned (≠'auto'), else the top `KNOWN_CODEX` id.
+ *   - coder is codex  → `'sonnet'` (the recall-oriented Claude reviewer)
+ *   - coder is Claude → the Codex-budget cell (`sol:high` or `terra:medium`),
+ *     or `'opus'` when Codex is unavailable (never block)
+ * A pinned `CODEX_MODEL` still outranks the tier selected by the budget table.
  */
-export function resolveQeSpec(env) {
-    if (coderIsCodex(env))
-        return 'opus';
+export function resolveQeSpecForCoder(coderCodex, env) {
+    if (coderCodex)
+        return 'sonnet';
     const CODEX_AVAILABLE = env.codexAvailable !== false;
     if (!CODEX_AVAILABLE)
         return 'opus';
-    return 'codex:' + topCodexId(env) + ':high';
+    const budget = resolveBudgetMode(env.budget);
+    return budget.codex === 'eco'
+        ? 'codex:' + codexIdForTier('workhorse', env) + ':medium'
+        : 'codex:' + codexIdForTier('flagship', env) + ':high';
+}
+export function resolveQeSpec(env) {
+    return resolveQeSpecForCoder(coderIsCodex(env), env);
 }
 /**
- * Whether the caller opted into routing at all. When FALSE (no `args.models`,
- * no codex knobs), every Claude stage resolves to `{}` → byte-identical to today.
+ * Whether the caller opted into routing at all. When FALSE (no axes, `args.models`,
+ * or Codex knobs), every Claude stage resolves to `{}` → byte-identical to today.
  */
 export function routingRequested(env) {
     return (Object.keys(env.MODELS).length > 0 ||
+        env.primary !== undefined ||
+        env.budget !== undefined ||
         env.PLANNER === 'codex' ||
         env.CODER === 'codex' ||
         env.CODER === 'codex-fallback' ||
@@ -247,12 +361,12 @@ export function qeShouldUseCodex(env) {
  * Resolve a stage to its `agent()` opts fragment.
  *   1. explicit `MODELS[stage]` wins
  *   2. else if the user did NOT opt into routing → `{}` (byte-identical BC path)
- *   3. else the DEFAULT TABLE fills the gap
+ *   3. else the primary × per-family-budget table fills the gap
  *   4. `code`/`qe` `null` sentinels resolve via the coder / cross-model rules
  */
 export function resolveStageModel(stage, env) {
     if (env.usageOverride) {
-        const r = (env.usageReasoning && env.usageReasoning[stage]) || OVERRIDE_REASONING[stage] || 'high';
+        const r = (env.usageReasoning && env.usageReasoning[stage]) || STAGE_EFFORT.override[stage] || 'medium';
         const o = specToOpts('codex:' + topCodexId(env) + ':' + r, env);
         o._usageSwitched = true;
         return o;
@@ -261,7 +375,18 @@ export function resolveStageModel(stage, env) {
     if (spec === undefined) {
         if (!routingRequested(env))
             return {};
-        spec = DEFAULT_MODELS[stage];
+        if (stage === 'code' && (env.CODER === 'codex' || env.CODER === 'codex-fallback')) {
+            return specToOpts(resolveCoderSpec(env), env);
+        }
+        if (stage === 'plan' && env.PLANNER === 'codex') {
+            return specToOpts('codex:' + env.CODEX_MODEL + ':high', env);
+        }
+        if (stage === 'qe') {
+            return specToOpts(resolveQeSpec(env), env);
+        }
+        const resolvedPrimary = env.primary || 'claude';
+        const cell = budgetTable(resolvedPrimary, resolveBudgetMode(env.budget), env)[stage];
+        spec = cell !== undefined ? cell : DEFAULT_MODELS[stage];
     }
     if (stage === 'code' && (spec === null || spec === undefined))
         return specToOpts(resolveCoderSpec(env), env);
@@ -297,15 +422,11 @@ export function codexEffortHint(opts) {
     return '';
 }
 // ── Step-7.5 CODE landed barrier (Codex out-of-band write flush) ────────────
-// Widened 2026-08-28 (MEASURED, not a guess): the dz-deadwood coder job ran 46m11s end to end, and
-// the slop-lint coder was independently confirmed STILL RUNNING (codex-companion status "running",
-// pid alive, mid-TDD-cycle, actively applying file changes) at 16m38s elapsed — a full 8x past the
-// old 120s window. The old window declared "genuinely not landed" and fed Step-8 QE a false empty
-// tree, producing a grade-D report entirely about an absence that was never real. This does not fix
-// the underlying conflation of TIMEOUT with CONFIRMED-ABSENCE (filed as a backlog item — the barrier
-// still cannot see the codex-companion job's own liveness) — it only narrows how often the false
-// negative fires for a realistic M-tier build, at the cost of a longer worst-case wait when the
-// coder truly produced nothing.
+// Widened 2026-08-28 (MEASURED): the dz-deadwood coder ran 46m11s, and slop-lint was still running
+// with its recorded PID alive at 16m38s when the old 120s window had already declared absence.
+// Changed 2026-08-30 (MEASURED: six false verdicts; plus task-mtfhglwk stayed status=running for
+// 8h51m after recorded PID 3639268 disappeared): this is now one git-evidence/backoff window inside
+// the liveness-driven loop, not the whole barrier. The separate hard ceiling bounds a live worker.
 export const DEFAULT_CODE_LANDING_MAX_WAIT_MS = 1_020_000;
 export const DEFAULT_CODE_LANDING_BACKOFF_MS = [
     1_000,
@@ -335,10 +456,10 @@ export const CODE_LANDED_BARRIER_SLEEPS_SECONDS = DEFAULT_CODE_LANDING_BACKOFF_M
 const CODE_LANDING_PIPELINE_PREFIXES = ['features/', '.dz/', '.agentic-qe/', 'roam/'];
 /** Bumped whenever the landing protocol's meaning changes. Recorded on every code-stage result so a
  *  pre-protocol checkpoint reads as no-checkpoint instead of resuming into new semantics. */
-export const LANDING_PROTOCOL_VERSION = 2;
+export const LANDING_PROTOCOL_VERSION = 3;
 /** R6: salted into the code stage's checkpoint hash PARTS (not the schema version — ADR-003 keeps
  *  `CKPT_SCHEMA_VERSION` at 'fa-ckpt-2' deliberately, so ONLY the code stage re-runs). */
-export const LANDING_HASH_TOKEN = 'landing-v2';
+export const LANDING_HASH_TOKEN = 'landing-v3';
 /**
  * The CLOSED landing-predicate vocabulary, as DATA (QE F6) — exhaustive-record derived, so `tsc`
  * fails the build if the union gains or loses a member. `'expected-path'` and `'any-code-change'`
@@ -1225,12 +1346,16 @@ export function codexExecCommand(input) {
     const modelId = String(o.modelId === undefined || o.modelId === null ? '' : o.modelId);
     if (!isSafeCodexId(modelId))
         return null;
+    const reasoning = o.reasoning === undefined || o.reasoning === null || o.reasoning === '' ? 'high' : String(o.reasoning);
+    if (!VALID_REASONING[reasoning])
+        return null;
     const raw = Number(o.timeoutSeconds);
     const seconds = raw === raw && raw !== Infinity && raw > 0 ? Math.floor(raw) : CODEX_EXEC_TIMEOUT_SECONDS;
     const repo = String(o.repo === undefined || o.repo === null ? '' : o.repo);
     const cd = repo === '' ? '' : ' -C ' + codexSq(repo);
     return timeoutBinOrDefault(o.timeoutBin) + ' ' + seconds + ' codex exec' + cd
-        + ' -m ' + codexSq(modelId) + ' ' + codexSq(String(o.prompt === undefined || o.prompt === null ? '' : o.prompt)) + ' < /dev/null';
+        + ' -m ' + codexSq(modelId) + ' -c model_reasoning_effort=' + codexSq(reasoning)
+        + ' ' + codexSq(String(o.prompt === undefined || o.prompt === null ? '' : o.prompt)) + ' < /dev/null';
 }
 export function codexReviewCommand(input) {
     const o = input || {};