@azure-id/orc 0.56.1 → 1.0.0

package/bin/webui/js/panels/lanes.js

@@ -0,0 +1,259 @@
+"use strict";
+/* panels/lanes.js — orc ui client
+   The `orc lane` noun, rendered: which lanes exist, which SHARED phases each
+   one runs, and the whole call catalogue.
+
+   Loaded by app.html in the order its numeric prefix names. Classic
+   script, no import/export: an ES module import carries no query string,
+   and every static request here needs the per-launch session token. */
+
+
+/* =================================================================== LANES == */
+
+// TWO TABS, on this panel's own precedent (Crosslink's two, Knowledge's five,
+// Extra's six). Phases and Calls answer two different questions about the same
+// noun — what a lane READS, in order, and what a lane RUNS — and stacking both
+// down one column made the second one something you had to know was there.
+//
+// The tab survives a re-render, exactly as `KN_TAB` and `EX_TAB` do: losing
+// your place because a fetch resolved is the small rudeness that makes a panel
+// feel unreliable.
+let LN_TAB = "phases";
+// The selected lane likewise. A lane picker that snaps back to `orc` every time
+// the panel repaints is a picker nobody uses twice.
+let LN_LANE = "orc";
+
+PANELS.lanes = function (host) {
+  head(host, t("lanes.title"), t("lanes.sub"));
+  section(
+    host,
+    () => read("/api/lanes").then((r) => r.data),
+    (d) => {
+      const out = frag();
+      const lanes = d.lanes || [];
+      if (!lanes.length) {
+        out.append(el("div", "empty", t("lanes.none")));
+        return out;
+      }
+      if (!lanes.some((l) => l.lane === LN_LANE)) LN_LANE = lanes[0].lane;
+
+      const body = el("div", "stack");
+      const paint = () => {
+        body.replaceChildren();
+        if (LN_TAB === "phases") phasesTab(body, lanes);
+        else callsTab(body);
+      };
+
+      // The panel's own `.tabs` convention: a flat strip driven by
+      // `aria-selected`, exactly as Knowledge and Runs build theirs. Keys are
+      // written out IN FULL rather than assembled from the tab id — a key built
+      // from a fragment is invisible to every check that looks for one.
+      const strip = el("div", "tabs");
+      const select = (which) => {
+        LN_TAB = which;
+        for (const b of strip.children) b.setAttribute("aria-selected", String(b.dataset.tab === which));
+        paint();
+      };
+      for (const [which, label] of [
+        ["phases", t("lanes.tab.phases")],
+        ["calls", t("lanes.tab.calls")],
+      ]) {
+        const b = el("button", null, label);
+        b.type = "button";
+        b.dataset.tab = which;
+        b.setAttribute("aria-selected", String(which === LN_TAB));
+        b.addEventListener("click", () => select(which));
+        strip.append(b);
+      }
+      out.append(strip, body);
+      paint();
+      return out;
+    }
+  );
+};
+
+/* ------------------------------------------------------------------ phases -- */
+
+function phasesTab(host, lanes) {
+  const picker = card(t("lanes.picker.title"));
+  picker.append(el("div", "note", t("lanes.picker.note")));
+
+  const sel = el("select", "text-input");
+  sel.setAttribute("aria-label", t("lanes.picker.aria"));
+  for (const l of lanes) {
+    const o = el("option", null, l.lane + (l.command ? "  " + l.command : ""));
+    o.value = l.lane;
+    if (l.lane === LN_LANE) o.selected = true;
+    sel.append(o);
+  }
+  picker.append(sel);
+  host.append(picker);
+
+  const slot = el("div", "stack");
+  host.append(slot);
+
+  const load = () => {
+    slot.replaceChildren(skeleton(3));
+    read("/api/lane/phases?lane=" + encodeURIComponent(LN_LANE))
+      .then((r) => slot.replaceChildren(phasesCard(r.data)))
+      .catch((e) => slot.replaceChildren(failBox(e)));
+  };
+  sel.addEventListener("change", () => {
+    LN_LANE = sel.value;
+    load();
+  });
+  load();
+}
+
+function phasesCard(d) {
+  const one = (d.lanes || [])[0];
+  const c = card(t("lanes.phases.title"));
+  if (!one) {
+    c.append(el("div", "empty", t("lanes.phases.unknown")));
+    return c;
+  }
+
+  // The trace tier and token are the CLI's words for how this lane narrates.
+  // They belong at the top because every phase below closes into one of them.
+  const meta = el("div", "lane-meta");
+  meta.append(el("span", "lane-meta-label", t("lanes.phases.trace")));
+  if (one.trace_tier) meta.append(chip(one.trace_tier));
+  if (one.trace_token) meta.append(chip("lane token " + one.trace_token, "lane"));
+  c.append(meta);
+
+  const phases = one.phases || [];
+  if (!phases.length) {
+    // AN EMPTY ANSWER IS AN ANSWER (v0.43.0). Five lanes keep their pipeline in
+    // their own spine on purpose, so "no shared phases" is a fact about this
+    // lane and not a fetch that failed. Saying nothing here would make the two
+    // look identical.
+    c.append(el("div", "empty", t("lanes.phases.inSpine")));
+    return c;
+  }
+
+  for (const p of phases) {
+    const row = el("div", "phase-row");
+    row.append(el("span", "phase-ord", String(p.ord)));
+
+    const mid = el("div", "phase-mid");
+    mid.append(el("div", "phase-id", p.id));
+    // A row names a FILE or a HEADING, never both and never neither — the
+    // manifest rule the two-way lint enforces. Whichever it is, it is a CLI
+    // string and is printed verbatim.
+    if (p.file) mid.append(el("div", "phase-file", p.file));
+    if (p.heading) mid.append(el("div", "phase-file", p.heading));
+    if ((p.calls || []).length) {
+      const calls = el("div", "phase-calls");
+      calls.append(el("span", "phase-calls-label", t("lanes.phases.calls")));
+      for (const id of p.calls) calls.append(chip(id, "lane"));
+      mid.append(calls);
+    }
+    row.append(mid);
+
+    const right = el("div", "phase-right");
+    // `when` is one of the CLI's own words (`always`, `on-phase`,
+    // `compile-time`, …). It is never softened into "sometimes".
+    if (p.when) right.append(chip(p.when, p.when === "always" ? "ok" : null));
+    if (p.read) right.append(el("div", "phase-read", p.read));
+    if ((p.layers || []).length) right.append(el("div", "phase-layers", p.layers.join(" · ")));
+    row.append(right);
+
+    if (p.optional_when) row.append(el("div", "phase-why", p.optional_when));
+    c.append(row);
+  }
+
+  if ((d.phase_files || []).length || (d.layer_set || []).length) {
+    const foot = el("div", "note");
+    foot.append(document.createTextNode(t("lanes.phases.foot")));
+    c.append(foot);
+  }
+  return c;
+}
+
+/* ------------------------------------------------------------------- calls -- */
+
+function callsTab(host) {
+  const slot = el("div", "stack");
+  host.append(slot);
+  slot.replaceChildren(skeleton(4));
+  read("/api/lane/calls")
+    .then((r) => slot.replaceChildren(callsCard(r.data)))
+    .catch((e) => slot.replaceChildren(failBox(e)));
+}
+
+function callsCard(d) {
+  const calls = d.calls || [];
+  const c = card(t("lanes.calls.title", { n: calls.length }));
+  c.append(el("div", "note", t("lanes.calls.note")));
+  if (!calls.length) {
+    c.append(el("div", "empty", t("lanes.calls.none")));
+    return c;
+  }
+
+  for (const call of calls) {
+    // EXPANDS IN PLACE, one row at a time — the Runs-row rule (v0.43.6). A
+    // detail box below a list means reading a row and then looking somewhere
+    // else for what it said.
+    const row = el("div", "call-row");
+    const h = el("button", "call-head");
+    h.type = "button";
+    h.setAttribute("aria-expanded", "false");
+    h.append(el("span", "call-caret", "▸"));
+    h.append(el("span", "call-cmd", call.cmd));
+    if (call.cost) h.append(chip(call.cost, call.cost === "free" ? "ok" : "warn"));
+    h.append(el("span", "call-lanes-n", tn((call.lanes || []).length, "lanes.calls.lanes")));
+
+    const detail = el("div", "call-detail");
+    detail.hidden = true;
+    // Every string below is the CLI's registry text and is never translated: it
+    // names commands, exit codes and reference files by their real ids.
+    const rows = [];
+    if (call.what) rows.push([t("lanes.calls.what"), call.what]);
+    if (call.when) rows.push([t("lanes.calls.when"), call.when]);
+    if (call.on_absent) rows.push([t("lanes.calls.onAbsent"), call.on_absent]);
+    if (call.never) rows.push([t("lanes.calls.never"), call.never]);
+    if (call.canonical) rows.push([t("lanes.calls.canonical"), call.canonical]);
+    detail.append(kvList(rows));
+
+    // The exit codes are a CONTRACT, so they are drawn as a table rather than
+    // folded into a sentence — a lane branches on these numbers.
+    const exits = call.exits || {};
+    const codes = Object.keys(exits);
+    if (codes.length) {
+      const ex = el("div", "call-exits");
+      ex.append(el("span", "call-exits-label", t("lanes.calls.exits")));
+      for (const code of codes) ex.append(el("span", "call-exit", code + " = " + exits[code]));
+      detail.append(ex);
+    }
+    if ((call.states || []).length) {
+      const st = el("div", "call-exits");
+      st.append(el("span", "call-exits-label", t("lanes.calls.states")));
+      for (const s of call.states) st.append(chip(s));
+      detail.append(st);
+    }
+    if ((call.lanes || []).length) {
+      const ls = el("div", "call-lane-chips");
+      ls.append(el("span", "call-exits-label", t("lanes.calls.calledBy")));
+      for (const l of call.lanes) ls.append(chip(l, "lane"));
+      detail.append(ls);
+    }
+
+    h.addEventListener("click", () => {
+      const open = h.getAttribute("aria-expanded") === "true";
+      // ONE ROW OPEN AT A TIME, the Runs-row rule again: thirty open rows is
+      // the wall this panel replaced.
+      for (const other of c.querySelectorAll(".call-head[aria-expanded='true']")) {
+        other.setAttribute("aria-expanded", "false");
+        other.parentElement.querySelector(".call-detail").hidden = true;
+      }
+      if (!open) {
+        h.setAttribute("aria-expanded", "true");
+        detail.hidden = false;
+      }
+    });
+
+    row.append(h, detail);
+    c.append(row);
+  }
+  return c;
+}

package/bin/webui/js/panels/overview.js

@@ -54,6 +54,16 @@ const FINDING_ROUTE = {
   // evicts the old package first), and `upgrade` is an action row on
   // MAINTENANCE — so that is genuinely the panel that can clear it.
   "legacy-global-package": { panel: "maintenance", cta: "overview.item.legacyGlobalPackage.cta" },
+  // v1.0.0 W5. The rule again: a demoted run is cleared by `orc extra promote`,
+  // and Recovery is the Extra tab where every other journal-shaped state is
+  // already rendered — so that is genuinely the panel that can clear it.
+  "extra-demoted-run": { panel: "extra", cta: "overview.item.extraDemotedRun.cta" },
+  // v1.0.0 W16. An INSTALL-FOOTPRINT finding, so it takes the documented
+  // default rather than an interesting exception: the thing that clears it is
+  // `orc update`, which is an action row on MAINTENANCE. It is spelled out
+  // rather than left to DEFAULT_FINDING_ROUTE because the CTA is specific --
+  // a reader who sees "lane config drifted" should be told which button.
+  "lane-keys-drifted": { panel: "maintenance", cta: "overview.item.laneKeysDrifted.cta" },
 };
 const DEFAULT_FINDING_ROUTE = { panel: "maintenance", cta: "overview.item.doctor.cta" };
 const findingRoute = (id) => FINDING_ROUTE[id] || DEFAULT_FINDING_ROUTE;

package/bin/webui/js/panels/settings.js

@@ -17,8 +17,8 @@
 // keys stay GREPPABLE: a build of a string key from a fragment is a key no
 // coverage check can see, and the check is the only thing standing between a
 // renamed key and a raw dotted string on somebody's screen.
-const TIER_LABEL_KEY = { common: "settings.tier.common", fable5: "settings.tier.fable5", advanced: "settings.tier.advanced" };
-const TIER_DESC_KEY = { common: "settings.tierDesc.common", fable5: "settings.tierDesc.fable5", advanced: "settings.tierDesc.advanced" };
+const TIER_LABEL_KEY = { common: "settings.tier.common", advanced: "settings.tier.advanced" };
+const TIER_DESC_KEY = { common: "settings.tierDesc.common", advanced: "settings.tierDesc.advanced" };
 const TIER_LABEL = (tier) => (TIER_LABEL_KEY[tier] ? t(TIER_LABEL_KEY[tier]) : tier);
 const TIER_DESC = (tier) => (TIER_DESC_KEY[tier] ? t(TIER_DESC_KEY[tier]) : "");
 
@@ -162,6 +162,12 @@ async function renderSettings(body) {
   // flips — which is how the precedence rule gets taught rather than described.
   out.append(ladderCard(d.score_table));
 
+  // WHO DECIDES WHAT (v1.0.0 W16). The ladder above answers one family;
+  // this answers all of them, and it is the picture a flat key list cannot
+  // draw: a contested setting is not decided by the key you are looking at,
+  // it is decided by the highest rank that resolved.
+  out.append(ranksCard(d.families, d.families_resolved, d.rank_states));
+
   // 36 keys in three flat lists is a wall, and the answer to "where is the one
   // I want" was scrolling. Each tier is now its own collapsible card, and the
   // toolbar filters across ALL of them at once — so finding a key never depends
@@ -169,7 +175,7 @@ async function renderSettings(body) {
   const tiers = [];
   out.append(settingsToolbar(d, tiers));
 
-  for (const tier of ["common", "fable5", "advanced"]) {
+  for (const tier of ["common", "advanced"]) {
     const keys = d.keys.filter((k) => k.tier === tier);
     if (!keys.length) continue;
 
@@ -234,6 +240,32 @@ async function renderSettings(body) {
     out.append(c);
   }
 
+  // A key ORC REMOVED, still sitting in the user's file. It is NOT an editable
+  // setting and it is NOT a hand-edited override, so it gets its own block —
+  // rendering it as either would tell the user a dead line still does
+  // something. The CLI computed the row; this only draws it.
+  if ((d.retired_keys || []).length) {
+    const c = card(t("settings.retired.title"));
+    c.append(el("div", "note", t("settings.retired.note")));
+    for (const r of d.retired_keys) {
+      const row = el("div", "setting shadowed");
+      const left = el("div");
+      const name = el("div", "setting-name");
+      name.append(document.createTextNode(r.key));
+      const lock = el("span", "lock");
+      lock.append(document.createTextNode("🔒 " + t("settings.retired.badge")));
+      name.append(lock);
+      left.append(name);
+      left.append(el("div", "setting-desc", t("settings.retired.readonly")));
+      left.append(el("div", "shadow-why", `${t("settings.retired.removedIn")} ${r.removed_in} — ${r.why}`));
+      const right = el("div", "setting-control");
+      right.append(el("div", "readonly-value", String(r.value)));
+      row.append(left, right);
+      c.append(row);
+    }
+    out.append(c);
+  }
+
   // Last block on the panel, and it sticks to the bottom of the viewport once
   // something is pending: with 36 keys across three tiers, an Apply you have to
   // go looking for is an Apply that gets forgotten.
@@ -243,6 +275,99 @@ async function renderSettings(body) {
   body.replaceChildren(out);
 }
 
+// WHO DECIDES WHAT (v1.0.0 W16) — the contested families, resolved.
+//
+// THE PANEL DECIDES NOTHING HERE. `families` is the CLI's static registry (which
+// ranks exist, in which order, and the question each family answers) and
+// `families_resolved` is what those ranks actually did against the config on
+// disk right now. Re-deriving a precedence in the browser is the exact drift
+// this panel exists to make impossible — the Flow-stepper rule, applied to
+// config.
+//
+// Only CONTESTED families are drawn. A family with one rank has no precedence
+// to teach, and a card that lists thirty uncontested rows to show two
+// interesting ones is a card nobody reads to the bottom of.
+//
+// Every state word is the CLI's own, from the closed set it publishes as
+// `rank_states` — never a friendlier synonym (`resolved`, `not-read`, `inert`,
+// `demoted`, `absent`, `partly-resolved`). A `why` is CLI prose and is never
+// translated: it names keys, runs, profiles and commands by their real ids.
+const RANK_STATE_KIND = {
+  resolved: "ok",
+  "partly-resolved": "ok",
+  "not-read": null,
+  inert: "warn",
+  demoted: "warn",
+  absent: null,
+};
+
+function ranksCard(families, resolved, states) {
+  const c = card(t("settings.ranks.title"));
+  c.id = "ranks-card";
+  c.append(el("div", "note", t("settings.ranks.note")));
+
+  const names = Object.keys(families || {}).filter((n) => (families[n] || {}).contested);
+  if (!names.length) {
+    c.append(el("div", "empty", t("settings.ranks.none")));
+    return c;
+  }
+
+  for (const name of names) {
+    const fam = families[name] || {};
+    const res = (resolved || {})[name] || {};
+    const block = el("div", "rank-family");
+
+    const h = el("div", "rank-family-head");
+    // The family id is a CLI id. The QUESTION beside it is the CLI's too —
+    // it is the whole reason the grouping means anything.
+    h.append(el("span", "rank-family-name", name));
+    h.append(el("span", "rank-family-q", fam.question || ""));
+    block.append(h);
+
+    // WHAT ANSWERED, stated before the ladder rather than left to be inferred
+    // from which row happens to be green. `resolved_by` is null on a terminal
+    // rank, which is not a gap: it means nothing above the floor resolved.
+    if (res.resolved_at) {
+      const by = el("div", "rank-answer");
+      by.append(
+        document.createTextNode(
+          res.resolved_by
+            ? t("settings.ranks.answeredBy", { prio: res.resolved_at, key: res.resolved_by })
+            : t("settings.ranks.answeredByDefault", { prio: res.resolved_at })
+        )
+      );
+      block.append(by);
+    }
+
+    for (const r of res.ranks || fam.ranks || []) {
+      const row = el("div", "rank-row" + (r.state === "resolved" ? " is-resolved" : ""));
+      row.append(el("span", "rank-prio", r.prio));
+      // A rank is either a KEY or the family's terminal floor. The floor has no
+      // key on purpose — it is "the thing that happens when nobody chose" — and
+      // rendering it as a key would invite somebody to look for it in the file.
+      row.append(el("span", "rank-key" + (r.key ? "" : " is-terminal"), r.key || r.terminal || ""));
+      const st = r.state || "absent";
+      // An unknown state is RENDERED, not swallowed: the CLI owns this set, and
+      // a panel that silently drops a word it does not recognise is a panel that
+      // hides the next state somebody adds.
+      row.append(chip(st, RANK_STATE_KIND[st] === undefined ? null : RANK_STATE_KIND[st]));
+      if (r.why) row.append(el("div", "rank-why", r.why));
+      block.append(row);
+    }
+    c.append(block);
+  }
+
+  // The closed set, once, at the bottom. It is what makes an unfamiliar chip
+  // above readable without leaving the page.
+  if ((states || []).length) {
+    const legend = el("div", "rank-legend");
+    legend.append(el("span", "rank-legend-label", t("settings.ranks.legend")));
+    for (const s of states) legend.append(chip(s, RANK_STATE_KIND[s] === undefined ? null : RANK_STATE_KIND[s]));
+    c.append(legend);
+  }
+  return c;
+}
+
 function ladderCard(table) {
   const c = card(t("settings.ladder.title"));
   c.id = "ladder-card"; // the FLIP morph finds it by id, never by a :has() query
@@ -324,6 +449,27 @@ function settingRow(k, panelBody, edits) {
   // translated. They name keys, values and precedence rules by their real ids.
   left.append(el("div", "setting-desc", k.desc));
   if (k.shadow_reason) left.append(el("div", "shadow-why", k.shadow_reason));
+  // WHICH LANES READ THIS (v1.0.0 W16). `k.lanes[]` is the CLI's own
+  // `CONFIG_META[].lanes[]` — the same list `orc lane config` filters on, and
+  // the same list a two-way lint already refuses to let drift. It answers the
+  // question a settings screen otherwise leaves you guessing at: I changed
+  // this, so what did I just change? A lane name is a CLI id and is never
+  // translated.
+  //
+  // AN EMPTY LIST IS AN ANSWER AND KEEPS ITS ROW. Ten keys are permanently
+  // empty and the lint has an allowlist naming every one of them: they are
+  // OPERATING keys of the `orc extra` bridge — a lane calls `orc extra
+  // dispatch` and the CLI reads `extra_timeout_s`, so no lane ever names it.
+  // Skipping the line would make "no lane reads this" look identical to "we
+  // did not render it", which is the distinction this whole row exists to
+  // draw.
+  {
+    const lanes = el("div", "setting-lanes");
+    lanes.append(el("span", "setting-lanes-label", t("settings.lanes.label")));
+    if ((k.lanes || []).length) for (const lane of k.lanes) lanes.append(chip(lane, "lane"));
+    else lanes.append(el("span", "setting-lanes-none", t("settings.lanes.none")));
+    left.append(lanes);
+  }
 
   const right = el("div", "setting-control");
   right.append(controlFor(k, edits));

package/package.json

@@ -1,39 +1,39 @@
-{
-  "name": "@azure-id/orc",
-  "version": "0.56.1",
-  "description": "ORC — an orchestrator skill constellation for Claude Code: intake, planning, scored parallel subagents, code-pattern matching, review, verify, ship, plus a project knowledge-base wiki.",
-  "bin": {
-    "orc": "bin/cli.js"
-  },
-  "files": [
-    "README.md",
-    "README-id.md",
-    "CHANGELOG.md",
-    "bin/",
-    "mock-run/",
-    "templates/"
-  ],
-  "scripts": {
-    "postinstall": "node -e \"try{require('fs').accessSync(require('path').join(__dirname,'bin','cli.js'));console.log('\\nORC installed. Run: orc init  (or orc init --global)\\n')}catch(e){console.error('\\n[orc] WARNING: bin/cli.js missing from this install — the repo/publish was incomplete. Reinstall from a complete source.\\n')}\"",
-    "build:agents": "node bin/build-agents.js",
-    "test": "node --test --test-concurrency=6 test/",
-    "verify": "node bin/build-agents.js --check && node bin/verify-package.js && node bin/verify-contracts.js",
-    "prepack": "node bin/build-agents.js --check && node bin/verify-package.js && node bin/verify-contracts.js && node --test --test-concurrency=6 test/"
-  },
-  "keywords": [
-    "claude",
-    "claude-code",
-    "orchestrator",
-    "skills",
-    "agents",
-    "ai"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">=18"
-  },
-  "repository": {
-    "type": "git",
-    "url": "github:azure-id/orc"
-  }
-}
+{
+  "name": "@azure-id/orc",
+  "version": "1.0.0",
+  "description": "ORC — an orchestrator skill constellation for Claude Code: intake, planning, scored parallel subagents, code-pattern matching, review, verify, ship, plus a project knowledge-base wiki.",
+  "bin": {
+    "orc": "bin/cli.js"
+  },
+  "files": [
+    "README.md",
+    "README-id.md",
+    "CHANGELOG.md",
+    "bin/",
+    "mock-run/",
+    "templates/"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"try{require('fs').accessSync(require('path').join(__dirname,'bin','cli.js'));console.log('\\nORC installed. Run: orc init  (or orc init --global)\\n')}catch(e){console.error('\\n[orc] WARNING: bin/cli.js missing from this install — the repo/publish was incomplete. Reinstall from a complete source.\\n')}\"",
+    "build:agents": "node bin/build-agents.js",
+    "test": "node bin/test-run.js",
+    "verify": "node bin/build-agents.js --check && node bin/verify-package.js && node bin/verify-contracts.js",
+    "prepack": "node bin/build-agents.js --check && node bin/verify-package.js && node bin/verify-contracts.js && node bin/test-run.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "orchestrator",
+    "skills",
+    "agents",
+    "ai"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "github:azure-id/orc"
+  }
+}

package/templates/agents/MODEL-MAPPING.md

@@ -3,7 +3,7 @@
 Single-role, model-specific agents. The orchestrator dispatches BY AGENT NAME —
 model is pinned in frontmatter, not requested in prose. No agent is multi-role.
 
-## Executors (score-mapped by the single 8-band table in config.md)
+## Executors (score-mapped by the single 6-band table in config.md)
 
 | Score band | Agent | Model | Effort |
 |-----------|-------|-------|--------|
@@ -11,14 +11,20 @@ model is pinned in frontmatter, not requested in prose. No agent is multi-role.
 | [30,40)  | orc-executor-sonnet-4-6-med  | claude-sonnet-4-6 | medium |
 | [40,55)  | orc-executor-sonnet-4-6-high | claude-sonnet-4-6 | high |
 | [55,65)  | orc-executor-sonnet-5-high   | claude-sonnet-5   | high |
-| [65,70)  | orc-executor-opus-4-7-med    | claude-opus-4-7   | medium |
-| [70,80)  | orc-executor-opus-4-7-high   | claude-opus-4-7   | high |
-| [80,90)  | orc-executor-opus-4-8-high   | claude-opus-4-8   | high |
-| [90,100] | orc-executor-opus-5-high     | claude-opus-5     | high |
+| [65,90)  | orc-executor-opus-5-low      | claude-opus-5     | low |
+| [90,100] | orc-executor-opus-5-med      | claude-opus-5     | medium |
 
-Score→executor mapping lives in config.md (one canonical 8-band table;
+Score→executor mapping lives in config.md (one canonical 6-band table;
 `rubric_bands` is granularity only, not a preset selector).
 
+**Executors no band names — they still ship.**
+`orc-executor-opus-4-7-med`, `orc-executor-opus-4-7-high`,
+`orc-executor-opus-4-8-high` and `orc-executor-opus-5-high` are still generated
+and still installed. Since v1.0.0 they are reachable only when a user names one
+explicitly: `rubric_bands_override`, `orc diy`'s `fixed_executor`, or
+`extra_fallback_agent`. They are not deleted because a table change is not a
+model change, and an agent's model change is always a RENAME.
+
 ## Fixed-role agents
 
 | Agent | Model | Effort | Role |
@@ -36,8 +42,8 @@ Score→executor mapping lives in config.md (one canonical 8-band table;
 | orc-retro-sonnet-5-high | claude-sonnet-5 | high | mine behavior traces → calibration report (/orc-retro; read-only) |
 | orc-wiki-scanner-opus-4-8-high | claude-opus-4-8 | high | scan ONE wiki coverage area → evidence-anchored doc body + crosslink tags (/orc-wiki only; read-only against the project). The DEEP half of the v0.46.0 tier ladder: first scan · STRUCTURAL · wide delta · a new exported symbol |
 | orc-wiki-scanner-sonnet-5-high | claude-sonnet-5 | high | the LIGHT half of the same ladder — an existing doc whose covered files moved by a small, no-new-surface delta. IDENTICAL return contract; it escalates with `needs_context` rather than under-delivering. Never used for a first scan |
-| orc-executor-opus-5-med | claude-opus-5 | medium | `opus5_only` ladder ONLY — the [40,80) band (never dispatched by the default 8-band table) |
-| orc-executor-opus-5-low | claude-opus-5 | low | `opus5_only` ladder ONLY — the [0,40) band, and the forced mini/fast executor (never dispatched by the default 8-band table) |
+| orc-executor-opus-5-med | claude-opus-5 | medium | the `[90,100]` band in BOTH tables |
+| orc-executor-opus-5-low | claude-opus-5 | low | the default table's `[65,90)`, `opus5_only`'s `[0,90)`, and the forced mini/fast executor |
 | orc-advisor-opus-5-xhigh | claude-opus-5 | xhigh | ultra Phase U0 advisory brief + rubric + clarification questions (read-only; /orc-ultra only) |
 | orc-judge-opus-5-xhigh | claude-opus-5 | xhigh | ultra judgment gates — analysis / plan / implementation (read-only; /orc-ultra only) |
 | orc-learn-writer-opus-5-low | claude-opus-5 | low | deepen ONE feature → learning-docs/<slug>/ (/orc-learn only; git-ignored output) |
@@ -58,15 +64,14 @@ Score→executor mapping lives in config.md (one canonical 8-band table;
 
 `opus5_only` FORCES every dispatched role onto `claude-opus-5`, with effort as
 the only cost dial. Each agent below replaces its default with the same slice
-and the same return contract. Effort is PINNED per role (unlike `fable5_effort`,
-no CLI rewrites these). Full mapping + precedence:
+and the same return contract. Effort is PINNED per role — no CLI rewrites
+these. Full mapping + precedence:
 `../skills/_shared/opus5-only.md`.
 
 | Agent | Model | Effort | Replaces |
 |-------|-------|--------|----------|
-| orc-executor-opus-5-low | claude-opus-5 | low | the `[0,40)` band · orc-mini's and orc-fast's fixed executor |
-| orc-executor-opus-5-med | claude-opus-5 | medium | the `[40,80)` band |
-| orc-executor-opus-5-high | claude-opus-5 | high | the `[80,100]` band |
+| orc-executor-opus-5-low | claude-opus-5 | low | the `[0,90)` band · orc-mini's and orc-fast's fixed executor |
+| orc-executor-opus-5-med | claude-opus-5 | medium | the `[90,100]` band |
 | orc-analyze-mini-opus-5-med | claude-opus-5 | medium | orc-analyze-mini-sonnet-5-high |
 | orc-planner-mini-opus-5-med | claude-opus-5 | medium | orc-planner-mini-sonnet-5-high |
 | orc-scout-opus-5-low | claude-opus-5 | low | orc-scout-sonnet-4-6-high |
@@ -80,22 +85,6 @@ verifier, test-author, combiner, learn-writer, advisor, judge — dispatch
 unchanged under this mode. **Never forced:** `orc-trace-writer-haiku-4-5` (it
 transcribes a packet, no reasoning) and orc-diy (its table is compile-owned).
 
-## Fable 5 role-override agents (hard-gated; dispatched only when configured)
-
-*(Entirely INERT while `opus5_only: true` — that mode outranks this one.)*
-
-Used ONLY when `fable5_enabled: true` and the role is in `fable5_roles` — each
-replaces its default role agent with the same slice/contract. Effort defaults to
-`medium` and is rewritten in-place by `orc config set fable5_effort <v>`.
-
-| Agent | Model | Effort | Replaces |
-|-------|-------|--------|----------|
-| orc-analyst-fable-5 | claude-fable-5 | fable5_effort | orc-system-analyst-opus-5-high |
-| orc-planner-fable-5 | claude-fable-5 | fable5_effort | orc-planner-opus-5-med |
-| orc-advisor-fable-5 | claude-fable-5 | fable5_effort | orc-advisor-opus-5-xhigh (ultra) |
-| orc-judge-fable-5 | claude-fable-5 | fable5_effort | orc-judge-opus-5-xhigh (ultra) |
-| orc-reviewer-fable-5 | claude-fable-5 | fable5_effort | orc-reviewer-opus-5-med |
-
 Mini execution reuses orc-executor-sonnet-5-high. Fast-lane (orc-fast)
 execution reuses orc-executor-sonnet-4-6-high — no dedicated agent. Under
 `opus5_only` both reuse orc-executor-opus-5-low.
@@ -114,8 +103,7 @@ agent to spawn before EVERY dispatch, and reuses shipped agents:
 The only dispatch it does not re-ask is build-repair rounds 1–2, which reuse the
 executor the user already chose for that entry; round 3 asks again.
 
-**`opus5_only`, `fable5_enabled`/`fable5_roles`, and `rubric_bands_override` are
-all INERT in this lane** — they would silently collapse the user's choice. It is
+**`opus5_only` and `rubric_bands_override` are both INERT in this lane** — they would silently collapse the user's choice. It is
 the one exception to `opus5_only`'s otherwise flat precedence. See
 `skills/_shared/opus5-only.md` and `skills/orc-quick/references/dispatch-gate.md`.
 
@@ -136,12 +124,12 @@ The orchestrator (main session) is NOT an agent file.
 Model IDs use the Platform/API dateless format (confirmed at
 platform.claude.com/docs/en/about-claude/models/model-ids-and-versions):
 claude-haiku-4-5, claude-sonnet-4-6, claude-sonnet-5, claude-opus-4-7,
-claude-opus-4-8, claude-opus-5 (the top executor band + the core fixed roles),
-and claude-fable-5 (the Fable 5 role-override agents).
+claude-opus-4-8 and claude-opus-5 (the top executor band + the core fixed
+roles).
 
 1. **Run `/agents`** to confirm Claude Code accepts these full IDs in agent
-   frontmatter — in particular `claude-haiku-4-5` and `claude-fable-5`, the two
-   newest ids. If it wants short aliases (opus/sonnet/haiku) or dated IDs, adjust
+   frontmatter — in particular `claude-haiku-4-5` and `claude-opus-5`. If it
+   wants short aliases (opus/sonnet/haiku) or dated IDs, adjust
    each `model:` field. The full IDs are valid at the API level but Claude Code
    may normalize differently.
 2. **Confirm `effort:` is a valid CLI frontmatter field.** If the CLI ignores