@1aboveio/skills 0.0.0-stage → 1.0.0

package/skills/engineering/harness-runtime/references/model-catalog-seed.json

@@ -0,0 +1,408 @@
+{
+  "seededAt": "2026-09-30",
+  "models": [
+    {
+      "canonical": "fable",
+      "family": "anthropic",
+      "ids": {
+        "claude-code": "fable"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "frontier"
+        }
+      },
+      "note": "claude-fable-5, Mythos-class; current-gen frontier — reviewer material. Seeded from the claude-code catalog only; no codex/pi entry exists at this id."
+    },
+    {
+      "canonical": "opus",
+      "family": "anthropic",
+      "ids": {
+        "claude-code": "opus"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "balanced-coder"
+        }
+      },
+      "note": "Opus 4.8 — balanced-coder at high. BENCHMARK (rule 6), official DeepSWE v1.1: 51.8%±4.6 at high (113 tasks, board updated 2026-08-13). The measured high point overlaps the 53.8%±2.3 balanced-coder reference from Grok 4.5, so it is not tiered from Opus's separate 59.0%±1.8 max run. Seeded from the claude-code catalog only."
+    },
+    {
+      "canonical": "sonnet",
+      "family": "anthropic",
+      "ids": {
+        "claude-code": "sonnet",
+        "pi": "anthropic/claude-sonnet-5"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "balanced-coder"
+        }
+      },
+      "note": "Confirmed alias: sonnet (claude-code) = anthropic/claude-sonnet-5. Balanced-coder at high: official DeepSWE v1.1 measured 48.2%±4.5 at high (113 tasks, board updated 2026-08-13), overlapping the balanced-coder reference band. No pi catalog entry exists yet at that id, so no pi tier is seeded here — the alias only lets a future pi discovery of anthropic/claude-sonnet-5 resolve to this canonical entry."
+    },
+    {
+      "canonical": "gpt-6-astra",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-6-astra",
+        "codex": "gpt-6-astra",
+        "pi": "openai/gpt-6-astra"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "frontier"
+        },
+        "codex": {
+          "high": "frontier"
+        },
+        "pi": {
+          "high": "frontier"
+        }
+      },
+      "note": "Agrees across all three harnesses: current-gen frontier at high. BENCHMARK (rule 6), official DeepSWE v1.1: 73.2%±3.4 at high (113 tasks, four runs, board updated 2026-09-03). The measured high point overlaps the frontier reference band and is banked instead of Astra's separate 74.1%±2.8 xhigh best result; xhigh/max are not default candidates because DeepSWE measured high. Canonical API model id is gpt-6-astra; gpt-6-astro is not an alias. Availability remains subject to per-run harness discovery (rule 3)."
+    },
+    {
+      "canonical": "gpt-6.1-sol",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-6.1-sol",
+        "codex": "gpt-6.1-sol",
+        "pi": "openai/gpt-6.1-sol"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "frontier"
+        },
+        "codex": {
+          "high": "frontier"
+        },
+        "pi": {
+          "high": "frontier"
+        }
+      },
+      "note": "Agrees across all three harnesses: frontier at high. ADDED 2026-09-30 (released 2026-09-29 at DevDay, $2/$10 per MTok, 1.05M context; the successor to gpt-6-sol, which Codex now labels previous generation). Availability verified 2026-09-30: codex-cli 0.159.2 lists gpt-6.1-sol (\"Latest workhorse model for coding and everyday work\"), and Pi enables openai/gpt-6.1-sol. BENCHMARK (rule 6), vendor-reported DeepSWE v1.1 from OpenAI's launch: 75.2% at high (~$1.50/task against ~$7.70 for gpt-6-astra); the same chart shows low 64, medium 73, xhigh 71, max 71. No confidence interval published. NOT on the official Datacurve board (issue datacurve-ai/deep-swe#102 open, no run). Banked at high because high is the vendor's best and measured point; medium (73) is a policy point for the explorer, not banked. 75.2 sits in the frontier band with gpt-6-astra@high 73.2%±3.4 and gpt-5.6-sol@high 69.4%±1.4, well above gpt-6-sol's 65.3. Re-tier from the official board when Datacurve runs it."
+    },
+    {
+      "canonical": "gpt-6-sol",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-6-sol",
+        "codex": "gpt-6-sol",
+        "pi": "openai/gpt-6-sol"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "deep-reasoner"
+        },
+        "codex": {
+          "high": "deep-reasoner"
+        },
+        "pi": {
+          "high": "deep-reasoner"
+        }
+      },
+      "note": "SUPERSEDED 2026-09-30 by gpt-6.1-sol in every team ladder (Codex now lists gpt-6-sol as \"Previous generation workhorse model\"); kept while discovery still yields it. Agrees across all three harnesses: deep-reasoner at high. ADDED 2026-09-23 (released 2026-09-22, $2/$10 per MTok, positioned by OpenAI as the model built to power complex coding and agentic workflows). BENCHMARK (rule 6), vendor-reported DeepSWE v1.1 from OpenAI's launch chart: 65.3% at high ($0.64/task); the same chart shows low 37.2, medium 56.6, xhigh 66.6, max 68.8. No confidence interval published. NOT on the official Datacurve board (last updated 2026-09-22, which lists only Astra among GPT-6). Banked at high because the vendor measured high; the xhigh/max points are not banked. 65.3 sits inside the deep-reasoner band with gpt-5.5@high 64.4%±3.1 and grok-4.6@high 65.2%±1.5, clearly above the balanced-coder cluster (terra 53.8, grok-4.5 53.8) and below the frontier cluster (gpt-5.6-sol 69.4%±1.4, gpt-6-astra 73.2%±3.4). Not the successor to gpt-5.6-sol's frontier seat: at max it scores 68.8 against 5.6-sol's 72.7. The natural deep-reasoner slot holder now that gpt-5.5 retires from Codex on 2026-10-14. Re-tier from the official board when Datacurve runs it."
+    },
+    {
+      "canonical": "gpt-6-luna",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-6-luna",
+        "codex": "gpt-6-luna",
+        "pi": "openai/gpt-6-luna"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "balanced-coder",
+          "max": "balanced-coder"
+        },
+        "codex": {
+          "high": "balanced-coder",
+          "max": "balanced-coder"
+        },
+        "pi": {
+          "high": "balanced-coder",
+          "max": "balanced-coder"
+        }
+      },
+      "note": "Agrees across all three harnesses: balanced-coder at max. ADDED 2026-09-23 (released 2026-09-22, $0.10/$0.50 per MTok, OpenAI's most efficient model for focused, high-volume tasks). BENCHMARK (rule 6), vendor-reported DeepSWE v1.1 from OpenAI's launch chart: 66.6% at max ($0.22/task); the chart also shows low 2.4 and medium 44.5. OpenAI published no high or xhigh point, so high is UNCLAIMED (rule 6: do not read a max score down to high) and the only banked point is max, the model's pushed point, not a throttled seat. No confidence interval; not on the official Datacurve board (2026-09-22). Like-for-like against the max/xhigh cluster it sits with its predecessor gpt-5.6-luna@max 67%±4, which was balanced-coder at max after the 2026-08-08 reband, so it takes the same band rather than the deep-reasoner band deepseek-v4-pro@max 62.7 holds; that inconsistency between the two precedents is recorded here, not resolved. CHANGED 2026-09-23: a high point is now banked as balanced-coder by HUMAN CLASSIFICATION, not benchmark-backed (rule 6 still forbids reading 66.6 down to high; the vendor chart brackets high between medium 44.5 and max 66.6 and the human placed it in the balanced band). Reason: the rush routine ladder runs Luna at high because max is too slow — Pi smoke 2026-09-23 on one small tool task: high 30s vs max 62s vs gpt-5.6-terra@high 29s, at ~1/20 Terra's cost, with a correct answer. A measured high point (official board or vendor) replaces this judgment and may re-tier it either way."
+    },
+    {
+      "canonical": "gpt-5.6-sol",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-5.6-sol",
+        "codex": "gpt-5.6-sol",
+        "pi": "openai/gpt-5.6-sol"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "frontier"
+        },
+        "codex": {
+          "high": "frontier"
+        },
+        "pi": {
+          "high": "frontier"
+        }
+      },
+      "note": "Agrees across all three harnesses: frontier at high. REVISITED 2026-09-16 after GPT-6 Astra: official DeepSWE v1.1 remains 69.4%±1.4 at high (113 tasks, four runs, board updated 2026-09-03). Sol-high's 68.0–70.8 confidence interval overlaps Astra-high's 69.8–76.7 interval and remains above the deep-reasoner references, so the newer OpenAI flagship does not justify a demotion. The separate 70.7%±0.8 xhigh and 72.7%±2.8 max runs are not banked because DeepSWE measured high."
+    },
+    {
+      "canonical": "gpt-5.5",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-5.5",
+        "codex": "gpt-5.5",
+        "pi": "openai/gpt-5.5"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "deep-reasoner"
+        },
+        "codex": {
+          "high": "deep-reasoner"
+        },
+        "pi": {
+          "high": "deep-reasoner"
+        }
+      },
+      "note": "Agrees across all three harnesses: deep-reasoner at high. BENCHMARK (rule 6), official DeepSWE v1.1: 64.4%±3.1 at high (113 tasks, board updated 2026-08-13). The separate xhigh point is not banked because DeepSWE measured high."
+    },
+    {
+      "canonical": "gpt-5.6-terra",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-5.6-terra",
+        "codex": "gpt-5.6-terra",
+        "pi": "openai/gpt-5.6-terra"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "balanced-coder"
+        },
+        "codex": {
+          "high": "balanced-coder"
+        },
+        "pi": {
+          "high": "balanced-coder"
+        }
+      },
+      "note": "Agrees across all three harnesses: balanced-coder at high. BENCHMARK (rule 6), official DeepSWE v1.1: 53.8%±4.3 at high (113 tasks, board updated 2026-08-13). Its separate xhigh/max runs are not banked because DeepSWE measured high. Codex and pi previously held a max point (deep-reasoner); it was dropped 2026-07-20 in all three catalogs when the team standardized on effort=high, and this seed followed."
+    },
+    {
+      "canonical": "gpt-5.6-luna",
+      "family": "openai",
+      "ids": {
+        "claude-code": "gpt-5.6-luna",
+        "codex": "gpt-5.6-luna",
+        "pi": "openai/gpt-5.6-luna"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "scoped-coder"
+        },
+        "codex": {
+          "high": "scoped-coder"
+        },
+        "pi": {
+          "high": "scoped-coder"
+        }
+      },
+      "note": "Agrees across all three harnesses: scoped-coder at high. BENCHMARK (rule 6), official DeepSWE v1.1: 44.2%±2.9 at high (113 tasks, board updated 2026-08-13). Its xhigh/max runs are not banked because DeepSWE measured high; a more expensive point that reaches another band is not a default operating point."
+    },
+    {
+      "canonical": "grok-4.5",
+      "family": "xai",
+      "ids": {
+        "claude-code": "grok-4.5",
+        "pi": "xai/grok-4.5"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "balanced-coder"
+        },
+        "pi": {
+          "high": "balanced-coder"
+        }
+      },
+      "note": "Balanced-coder in both harnesses at high. BENCHMARK (rule 6), official DeepSWE v1.1: 53.8%±2.3 at high (113 tasks, board updated 2026-08-13). Was seeded deep-reasoner under pi; demoted 2026-07-22 on human re-classification — the two harnesses agree, so this is no longer a harness-dependent entry. Not yet confirmed available in claude-code's own discovery (rule 3 applies regardless of this seed entry). Sibling grok-4.6 is a separate entry and does not re-tier 4.5."
+    },
+    {
+      "canonical": "grok-4.6",
+      "family": "xai",
+      "ids": {
+        "claude-code": "grok-4.6",
+        "pi": "xai/grok-4.6"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "deep-reasoner"
+        },
+        "pi": {
+          "high": "deep-reasoner"
+        }
+      },
+      "note": "Agrees across both harnesses it is seeded from: deep-reasoner at high. BENCHMARK (rule 6), official DeepSWE v1.1: 65.2%±1.5 at high (113 tasks, board updated 2026-08-13). It overlaps gpt-5.5's 64.4%±3.1 high point (deep-reasoner) and is clearly above Grok 4.5's 53.8%±2.3 high point (balanced-coder); the shared deep-reasoner band is the claim, not that it beats gpt-5.5. Its separate xhigh point is not banked because DeepSWE measured high. CONFIRMED 2026-09-23 against the board's all-efforts view (verified Datacurve run sampled 2026-08-26): high 65.19%±1.53; the board's Best view shows medium 67.5%±2.3 and xhigh 66.7%±2.2, neither banked — the effort choice stays high per rule 6. Successor grok-4.7 is a separate entry (vendor 71.0 at high, frontier) and does not re-tier 4.6. Codex holds no Grok entry. Availability is still per-harness discovery (rule 3)."
+    },
+    {
+      "canonical": "grok-4.7",
+      "family": "xai",
+      "ids": {
+        "claude-code": "grok-4.7",
+        "pi": "xai/grok-4.7"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "frontier"
+        },
+        "pi": {
+          "high": "frontier"
+        }
+      },
+      "note": "Agrees across both harnesses it is seeded from: frontier at high. ADDED 2026-09-23 (released 2026-09-21; API id grok-4.7; $2/$0.50/$6 per MTok under 200k context, same list price as grok-4.6; efforts low/medium/high/xhigh; 500k context). BENCHMARK (rule 6), vendor-reported DeepSWE v1.1 from SpaceXAI's launch chart: 71.0% at high (asterisked \"high effort\"; the same chart lists grok-4.6 at 65.2, which equals the official board's high point, so the chart is like-for-like at high). No confidence interval, and NOT on the official Datacurve board (last updated 2026-09-22, which lists grok-4.6 only). Like-for-like at high on the official board: gpt-6-astra 73.2%±3.4 and gpt-5.6-sol 69.4%±1.4 (frontier); gpt-5.5 64.4%±3.1, grok-4.6 65.2%±1.5, gpt-6-sol vendor 65.3 (deep-reasoner). 71.0 sits above 5.6-sol's high point and inside Astra's interval, so the frontier band is the claim, not a rank over Astra; if the official run lands at or below ~68 it belongs in deep-reasoner — re-tier when Datacurve publishes it. Its xhigh points on other xAI charts (CursorBench, Terminal-Bench) are not DeepSWE and are not banked. Codex holds no Grok entry. Availability is still per-harness discovery (rule 3); Pi lists xai/grok-4.7 as of 2026-09-23."
+    },
+    {
+      "canonical": "mimo-v2.5-pro",
+      "family": "xiaomi",
+      "ids": {
+        "claude-code": "mimo-v2.5-pro",
+        "pi": "xiaomi/mimo-v2.5-pro"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "scoped-coder"
+        },
+        "pi": {
+          "high": "scoped-coder"
+        }
+      },
+      "note": "Agrees across both harnesses it is seeded from: scoped-coder at high. Downgraded under pi from balanced-coder on 2026-08-02 by maintainer instruction, which ended a recorded harness disagreement — it had been the worked example of one (scoped-coder under claude-code, balanced-coder under pi: a mid-size model's ability to hold a long agentic trajectory being a property of the harness loop as much as the weights). That example is now historical; kimi-k2.7-code now agrees across both harnesses too. Not benchmark-backed (rule 6): no published point at high for this model, so both bands are human judgment. As scoped-coder in every harness it carries, this model is now slot-ineligible everywhere — recorded deliberately so it stops being re-asked, not hidden; promotion is a normal re-confirmation if it earns one."
+    },
+    {
+      "canonical": "mimo-v2.6-pro",
+      "family": "xiaomi",
+      "ids": {
+        "claude-code": "mimo-v2.6-pro",
+        "pi": "xiaomi/mimo-v2.6-pro"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "frontier"
+        },
+        "pi": {
+          "high": "frontier"
+        }
+      },
+      "note": "Agrees across both harnesses it is seeded from: frontier at high. ADDED 2026-09-23 (released 2026-09-21/22; API id mimo-v2.6-pro; open weights, trillion-parameter; $0.435/$0.87 per MTok, 1M context, 128K output). The API exposes deep thinking as an on/off switch only (`thinking: {type: enabled}`, on by default) — there are no graded reasoning efforts, so `high` here is the harness-default label for the single thinking-on operating point; xhigh/max would name the same point and are not separate candidates. BENCHMARK (rule 6), vendor-reported DeepSWE v1.1 71.9 from Xiaomi's release table (Xiaomi's own run of the public mini-swe-agent harness; its RL dashboard showed 72.57 avg@3 for the pre-release checkpoint). No confidence interval, and NOT on the official Datacurve board (last updated 2026-09-22, no MiMo entry). Like-for-like against the official board's high points: gpt-6-astra 73.2%±3.4 and gpt-5.6-sol 69.4%±1.4 (frontier); gpt-5.5 64.4%±3.1, grok-4.6 65.2%±1.5, gpt-6-sol vendor 65.3 (deep-reasoner). 71.9 sits above 5.6-sol's high point and inside Astra's interval, so the frontier band is the claim, not a rank over Astra; if the official run lands at or below ~68 it belongs in deep-reasoner — re-tier when Datacurve publishes it. Separate entry from mimo-v2.5-pro (scoped-coder by human judgment, no benchmark point); DeepSWE is a long-horizon agentic benchmark, so this score speaks directly to the trajectory-holding concern behind that downgrade, but only as a vendor number. Codex holds no MiMo entry. Availability is still per-harness discovery (rule 3); Pi lists xiaomi/mimo-v2.6-pro as of 2026-09-23."
+    },
+    {
+      "canonical": "deepseek-v4-pro",
+      "family": "deepseek",
+      "ids": {
+        "claude-code": "deepseek-v4-pro",
+        "pi": "deepseek/deepseek-v4-pro"
+      },
+      "tiers": {
+        "claude-code": {
+          "max": "deep-reasoner"
+        },
+        "pi": {
+          "max": "deep-reasoner"
+        }
+      },
+      "note": "Agrees across both harnesses it is seeded from: deep-reasoner at max. CHANGED 2026-08-13: 0813 GA replaced the 2026-08-01 preview classification (claude-code high:scoped-coder, pi high:balanced-coder — that disagreement is now historical). BENCHMARK (rule 6), vendor-reported DeepSWE v1.1 62.7 — DeepSeek V4 Pro 0813 Agent comparison table, 2026-08-12/13. BenchLM cites the same 62.7 as DeepSeek V4 Pro (Max); no CI, and DeepSeek did not publish a high-effort DeepSWE number for 0813. Banked at MAX because that is the only published operating point, so it is the model's pushed point, not a throttled seat (same posture as kimi-k3). Do NOT read 62.7 down onto high — measured max→high drops on this board have run 1 to 23 points, and a high point is unclaimed until someone measures it. Like-for-like against the official board's max/xhigh cluster: luna@max 67±4 (balanced-coder at max after the 2026-08-08 reband), gpt-5.5@xhigh 67±6 (deep-reasoner), opus-4.8@max 59±2 (deep-reasoner). 62.7 sits with that deep-reasoner band and above flash's official max 53±4 / vendor 54.4, so the name ordering now tracks the evidence (flash is now also banked at max: 53%±4 official / 54.4 vendor, balanced-coder). Not on the official DeepSWE v1.1 board (last updated 2026-08-07, 21 models) — vendor number, not an independent Datacurve run. No high point is claimed; do not restore the preview high bands from this score."
+    },
+    {
+      "canonical": "deepseek-v4-flash",
+      "family": "deepseek",
+      "ids": {
+        "claude-code": "deepseek-v4-flash",
+        "codex": "deepseek-v4-flash",
+        "pi": "deepseek/deepseek-v4-flash"
+      },
+      "tiers": {
+        "claude-code": {
+          "max": "balanced-coder"
+        },
+        "codex": {
+          "max": "balanced-coder"
+        },
+        "pi": {
+          "max": "balanced-coder"
+        }
+      },
+      "note": "Agrees across all three harnesses: balanced-coder at max. CHANGED 2026-08-13: the 2026-08-01 high:balanced-coder point was a mis-cited effort — DeepSWE v1.1 lists this model as deepseek-v4-flash [max] 53%±4 ($0.10, 108k out, 153 steps; board updated 2026-08-07), and DeepSeek's own 54.4 is the same max-effort run (V4-Flash-0731, DeepSeek Harness minimal, reasoning_effort=max). There is no published high-effort DeepSWE number, so high is unclaimed (rule 6: do not read a max score down to high). Like-for-like against the official max/xhigh cluster: grok-4.5 is 54%±2 at HIGH, not a peer at this effort; luna@max 67±4 is also balanced-coder at max after the 2026-08-08 reband; muse-spark-1.1@xhigh 53±3 sits on the same score. Sibling deepseek-v4-pro is deep-reasoner @max off vendor 62.7 — same effort, name ordering now tracks the evidence. The 55.4 figure previously cited as @high was the vendor max point, not a high measurement."
+    },
+    {
+      "canonical": "kimi-k2.7-code",
+      "family": "moonshot",
+      "ids": {
+        "claude-code": "kimi-k2.7-code",
+        "pi": "kimi-coding/kimi-for-coding"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "scoped-coder"
+        },
+        "pi": {
+          "high": "scoped-coder"
+        }
+      },
+      "note": "Agrees across Claude Code and Pi: scoped-coder at high."
+    },
+    {
+      "canonical": "gemini-3.5-flash",
+      "family": "google",
+      "ids": {
+        "claude-code": "gemini-3.5-flash"
+      },
+      "tiers": {
+        "claude-code": {
+          "high": "scoped-coder"
+        }
+      },
+      "note": "Seeded from the claude-code catalog only; no confirmed high-effort point exists (the only benchmark observation was at medium)."
+    },
+    {
+      "canonical": "kimi-k3",
+      "family": "moonshot",
+      "ids": {
+        "claude-code": "kimi-k3"
+      },
+      "tiers": {
+        "claude-code": {
+          "max": "frontier"
+        }
+      },
+      "note": "Seeded from the claude-code catalog only. Pi's catalog separately holds `kimi-coding/k3` (deep-reasoner @high) — plausibly the same underlying model, but the id does not plainly normalize (stripping the `kimi-coding/` prefix gives `k3`, not `kimi-k3`) and no human confirmed the pair, so the two stay as separate seed entries rather than a guessed alias. Flagged for human confirmation, not merged."
+    },
+    {
+      "canonical": "kimi-coding/kimi-for-coding-highspeed",
+      "family": "moonshot",
+      "ids": {
+        "pi": "kimi-coding/kimi-for-coding-highspeed"
+      },
+      "tiers": {
+        "pi": {
+          "high": "balanced-coder"
+        }
+      },
+      "note": "Seeded from the pi catalog only."
+    },
+    {
+      "canonical": "kimi-coding/k3",
+      "family": "moonshot",
+      "ids": {
+        "pi": "kimi-coding/k3"
+      },
+      "tiers": {
+        "pi": {
+          "high": "deep-reasoner"
+        }
+      },
+      "note": "Seeded from the pi catalog only. See `kimi-k3`'s note — not merged with claude-code's `kimi-k3` pending human confirmation of the alias."
+    }
+  ]
+}

package/skills/engineering/harness-runtime/references/model-catalog.md

@@ -0,0 +1,57 @@
+# Model catalog (skill-owned baseline, per-harness overrides)
+
+resolve-issues preflight must classify every discovered model (family · tier) before it can recommend a pick for each slot. The installed `harness-runtime` package provides the shared catalog baseline at `references/model-catalog-seed.json`; the per-harness JSON files below hold only **explicit, human-confirmed overrides**. A skill install or update replaces the shipped baseline, so its newer classifications apply on the next pre-flight wherever no local override exists. It never copies that baseline into a user file or silently changes an override. Training-data knowledge is not a discovery source, and neither is this file's *absence* of a model: only discovered or explicitly human-named models are eligible ([resolve-issues shared modules](../../resolve-issues/references/shared-modules.md)).
+
+**Read and write through [`model-catalog.mjs`](../model-catalog.mjs)** rather than hand-editing the JSON — it single-sources the prune predicate and the write paths. Run `model-catalog.mjs help`; the script is the source of truth for the precedence composition, the write-guards, and the shapes. At pre-flight step 2 **prefer `tiers --seen <ids>`**: it composes all three evidence arms (banked → cross-harness → team seed) with the precedence applied *inside* the command. A precedence or filtering rule stated only in prose is applied by an agent mid-gate from memory, and the failure is silent — exactly how rules 5 and 7 went wrong before 2026-07-20.
+
+## Location — skill baseline plus one override catalog per harness
+
+The skill-owned baseline resolves relative to the installed runtime, so the native Skills CLI refreshes it along with the rest of `harness-runtime`: `~/.agents/skills/harness-runtime/references/model-catalog-seed.json` in the supported global installation. A local override catalog belongs to one harness, at that harness's own user-config location: **Claude Code** `~/.claude/model-catalog.json`, **Codex** `~/.codex/model-catalog.json`, **Pi** `~/.pi/agent/model-catalog.json`, another harness its user-config dir (via `--file`).
+
+**Never merge harnesses into one override file.** The same model carries a different id per harness (`sonnet` in Claude Code is `anthropic/claude-sonnet-5` in Pi) — a shared file conflates id namespaces and lets staleness pruning judge entries a run's discovery was never going to see. Per-harness files make every `id` unambiguous and pruning naturally scoped to the harness actually looking. `--harness` guards writes against the file's own `harness` stamp — a sync or bank aimed at a file stamped for a different harness is refused, not merged. Absence is normal and desirable: with no override, the installed skill baseline supplies the classification; a discovered model absent from both falls through to discovery-source evidence.
+
+## Schema — the fields that carry judgment
+
+The script validates the shape; what follows is the *why* behind the load-bearing fields (see the header comment / `model-catalog.mjs --help` for the full field list).
+
+- `tiers` — **the entry's capability: a map from effort to the tier the model reaches there.** Bands, top to bottom:
+  - **`frontier`** — the current top end; home role: reviewer.
+  - **`deep-reasoner`** — a **capability band, not a chronology**: a deep reasoner below the current top end (a previous generation's frontier is the typical member, but a newly released model that lands in the band belongs here too). The implementer to recommend for a risk-heavy/complex run.
+  - **`balanced-coder`** — fast, capable, non-specialist; deep enough for routine work, not the hardest. The implementer to recommend for a routine run.
+  - **`scoped-coder`** — **executes a change someone else scoped; does not hold a task together across a long agentic trajectory.** It has **no home role and is never proposed for a slot** — that is what it is for. Banking a model as `scoped-coder` records the answer once and keeps a below-floor model out of every slot's candidate list, so it stops getting tagged `unconfirmed — please classify` every run. The exclusion is mechanized (`slotEligible`, wired to `SLOT_ELIGIBLE_TIERS`). **Marked, never filtered** — the classification is a real, useful answer, so what must not happen is it *reaching a slot list*, not the model being hidden. (Until 2026-07-20 `SLOT_ELIGIBLE_TIERS` was a constant nothing read, so the shipped seed handed a fresh install its five scoped-coder entries as team-endorsed slot options. Five is the count at that commit, verified against the file's history, and it is written as history on purpose: the live count moves whenever an entry is re-banded — it has already changed twice since — so quoting today's number here just plants the next stale fact. Count the current seed if you need the current count.) Promotion is a normal re-confirmation if the model later earns it — the band is a classification, not a blacklist.
+
+  A model with **two useful operating points** banks both, and pre-flight offers each as its own slot candidate (`example-coder-2 @ high (balanced-coder)` · `example-coder-2 @ max (deep-reasoner)`) — so one model can be the routine implementer *and*, pushed, the deep reasoner. **The two-point examples in this file use a deliberately fictional id.** They named a real model until 2026-07-20, when that model's second point was dropped in every catalog and the docs kept illustrating a two-point entry with a model that no longer had one — an example naming a real model goes stale every time that model is reclassified, and a reader checking their own catalog against it finds a contradiction and can't tell which side is wrong. Efforts are `high | xhigh | max`; **`high` is the floor**, because a point records what a model *reaches when pushed*, never a throttled-down cheap seat — a cheaper operating point is a cheaper **model** (pre-flight step 2). An effort with no banked point is **not claimed**: `tierAt` returns null rather than guessing.
+
+  This is `tier = f(model, effort)` — the shape removed on 2026-07-13, restored on **2026-07-19** with the cost that killed it removed. That removal was right about the *per-slot, per-run* effort question, which bought a confirmation per slot for no benefit; it stays gone. Points are banked **once, at classification**, so pre-flight reads them instead of asking.
+
+**Renamed / reshaped 2026-07-19 — every tier name now describes what a model *is*:** `prior-frontier` → `deep-reasoner` (the old name encoded a *chronology*) and `mid-tier` → `balanced-coder` (encoded an *ordinal position*, and an inaccurate one — with three bands it is the bottom, not the middle); the single-point `tier` (+ optional `effort`) fields became the `tiers` map. All three legacy forms are **accepted, not rejected**: `bank` normalizes them and the `sync` at every pre-flight read migrates entries in place and reports them, so an older catalog heals itself on first use.
+
+## Skill-owned baseline (`references/model-catalog-seed.json`) — read-only, ships with the skill
+
+The three local catalogs above are **override-level** — a teammate installing the skill fresh starts every one empty and immediately reads the skill-owned baseline. The baseline carries the team's accumulated judgment in one file, checked in beside `model-catalog.mjs` under `references/` (not a user-config location — there is exactly one baseline shared by every harness, unlike the per-harness override catalogs). Its fields mirror the per-user schema with two differences that carry judgment:
+
+- `ids` — the map from harness name to **that harness's own id for this model**, resolved once by a human at authoring time (never by live normalization at read time). **Do not add an id pairing beyond what plain `provider/`-prefix normalization gives or what a human has explicitly confirmed** — a wrong alias produces a confident bad slot pick, worse than no pre-fill; when unsure, ship the model as separate per-harness entries instead of guessing a pairing (the seed's `kimi-k3` / `kimi-coding/k3` entries are the worked example: same provider, plausibly the same model, kept separate because the id doesn't plainly normalize and no human confirmed it).
+- `tiers` — **per-harness**, never collapsed to one value: a model's tier is a function of the harness loop as much as the weights (a mid-size model can hold a long agentic trajectory in one harness's loop and not another's), so an entry that disagrees across harnesses states each harness's tier honestly. Of the models this repo seeded from, 0 shared across the three catalogs genuinely disagree per harness (count the seed if you need today's number — models leave this set as they are re-banded). `deepseek-v4-pro` was the last one (claude-code high:scoped-coder vs pi high:balanced-coder) and left on 2026-08-13 when 0813 GA collapsed it to an agreeing max:deep-reasoner point; each entry records what it replaced and is pinned in the seed test, so a drift back has to be deliberate. Collapsing that would silently overrule a real, harness-specific measurement.
+
+`seededAt` is checked-in data and will age; pre-flight surfaces `team seed is N days old` once `seededAt` is more than **~90 days** old as a nudge to an owner, not a hard gate — a stale entry only ever costs the human a correction, never a silent wrong pick, because the seed only ever pre-fills a *proposal*. (No script computes seed age — pre-flight reads `seededAt` and applies the nudge; this is the concrete home for that ~90-day threshold.)
+
+## Lifecycle rules
+
+1. **Read at pre-flight step 2, before classifying.** A discovered model with a catalog entry keeps its banked `family`/`tiers` — pre-fill the proposal from it, don't re-ask. One exception is surfaced, not silent: a `frontier` entry whose provider has since shipped a newer top-line model (that discovery also yielded) may have aged into `deep-reasoner` — propose the demotion for confirmation. Everything else falls through to discovery-source evidence, and failing that `unconfirmed — please classify`.
+2. **Bank at confirmation (pre-flight step 4).** The human's confirmation is the only thing that writes a *classification* (`family`/`tiers`/`note`) — never bank a machine guess. A banked point above `high` in particular is a claim the human has *seen* the model reach that tier when pushed; absent that, bank only `high`. The two maintenance writes rule 4 makes at read time record observation, not judgment, and are the only machine writes allowed.
+3. **Never an availability source.** A cataloged model this run's discovery did not yield is **not proposable** (pre-flight step 1's rule stands). The catalog answers "what is this model," never "what models exist here."
+4. **Auto-prune by staleness, not by single absence.** `sync` deletes every entry unseen for more than 60 days (never silently). One missed run doesn't prune (quota, region, temporary removal); more than 60 days unseen means the model left this user's runtime, and a pruned model that later resurfaces just gets re-classified — one question, the price of a self-cleaning catalog.
+   - **Prune watches `lastSeenAt`; classification-staleness watches `confirmedAt` — two axes, not one.** A model discovered every day never prunes, yet its *tier* can be frozen for weeks: grok-4.5 stayed `deep-reasoner` (confirmed 2026-07-19) long after the seed demoted it to `balanced-coder`, because `lastSeenAt` kept bumping and nothing watched the age of the *judgment*. `tiers --seen` flags any discovered entry whose `confirmedAt` is older than `CLASSIFY_STALE_AFTER_DAYS` (30) as `staleClassifications` — **surfaced for re-confirmation, never auto-changed** (unlike prune, which acts). Staleness of judgment is a nudge; staleness of observation is a delete.
+5. **Another harness's catalog is tiering *evidence*, never more.** When a model is new to *this* harness's catalog, an entry in another catalog whose id **plainly matches** after normalizing the `provider/` prefix (`openai/gpt-5.6-sol` ↔ `gpt-5.6-sol`) supplies its banked `family`/`tiers` as the pre-fill, cited as such — the human still confirms this run, and the confirmation banks into *this* harness's file. Plainly means mechanically: harness-local aliases (`sonnet`) don't normalize and get no cross-harness pre-fill. One thing never transfers: **availability** (rule 3 applies doubly).
+6. **A public benchmark is tiering evidence, never availability — and only at a matching operating point.** A leaderboard (SWE-bench, DeepSWE, …) is discovery-source evidence for `tiers`, the same class as provider docs or pricing under rule 1: it pre-fills a proposal, the human still confirms, and it never says the model is runnable here. Two rules keep it usable:
+   - **Compare like-for-like points.** A leaderboard's headline column is usually each model's *best* effort, while the catalog banks `high`. They are not interchangeable: measured max→high drops have run **1 to 23 points** across models in a single benchmark version, so a max score implies almost nothing about the high point, and a model whose only published number is below `high` cannot be tiered from it at all. Band a point against peers *at the same effort*, or not at all.
+   - **Default to `high` when DeepSWE measured it.** The skill-owned baseline banks the `high` point alone when the board has one; a better `xhigh` or `max` result does not add a second default candidate. When the board has no `high` run, bank the published `xhigh` or `max` point as the model's only measured operating point, and say why in its note. This keeps an effort choice from silently becoming a score-chasing policy while preserving an evidence-backed option for models without a `high` run.
+   - **Cite the source and version in the `note`** (`DeepSWE v1.1 @high 54%±2`), and say plainly when a classification is *not* benchmark-backed. Confidence intervals are part of the evidence, not decoration — where they overlap, the benchmark is not separating those models, and banding on the point estimate is fitting noise.
+7. **The skill-owned baseline is the shared default, never an availability source and never a silent override write — the load-bearing invariant.** When a discovered model has no banked entry (rule 1) and no cross-harness hit (rule 5), `seed-proposals --seen <ids>` supplies its per-harness `tiers` as the pre-fill, cited as such. The human may explicitly confirm a local override, which banks a normal entry (fresh `confirmedAt`) into the human's *own* per-harness file; the baseline itself never accumulates. Four things must hold:
+   - **Rule 3 applies to the seed, and this is the one that fails *open* if missed:** a model the seed carries but this run's discovery did not yield stays unproposable — `seed-proposals` mechanizes this by taking the discovered-id set as an argument and silently excluding everything outside it, never trusting a caller to filter afterward.
+   - **Read-only.** `bank` and `sync` refuse the seed file as a write target (by path and by shape — anything carrying `seededAt` is refused wherever it sits), and rule 4's staleness pruning does **not** apply: the seed records judgment, not observation.
+   - **Precedence, full order:** own banked entry → own other-harness catalog → **team seed** → discovery-source evidence (rule 6's benchmarks) → `unconfirmed — please classify`. A user's own measurement always beats the shipped default, and `seed-proposals` **enforces the order itself** rather than trusting a caller to apply it — a precedence rule a caller applies by hand is a rule that silently stops holding.
+   - **A banked entry outranks the seed per *model*, never per *effort*.** A banked entry is a **complete statement** of that model's operating points in this harness, so a model with any banked point takes no seed pre-fill at all. A per-effort merge would read a human's *deliberate deletion* of a point (banking `example-coder-2` at `{high}` after deciding its `max` point wasn't real) as *silence* and hand the point back from the seed forever. Deletion has to be expressible; per-model suppression makes it stick. `resolveModelTiers` takes whole `tiers` maps for exactly this reason — its predecessor took one scalar tier per source, so the per-model rule survived only as a comment telling callers not to merge point-by-point, and a signature that invites the bug its comment forbids is a trap.
+
+   `seed-proposals` returns `{proposals, suppressed}`; `suppressed` names each model the catalog outranked, flagging `disagrees: true` where the seed differs from what the human banked. Surface a disagreement as a **nudge to a seed owner** — never a proposal, never a reason to re-ask a settled classification. This is the only place seed staleness becomes visible (the seed can't be diffed against user-level catalogs in CI, since those live outside the repo); what CI *does* hold is the seed's internal shape.
+   - **A disagreement is date-aware — which side is stale depends on which is newer.** The default nudge ("your catalog wins; refresh the seed if yours is the better answer") assumes the *seed* went stale relative to the user's measurement. That is backwards when the seed is the fresher answer: `suppressed` also carries `seededAt`, `bankedConfirmedAt`, and `seedNewer` (`disagrees && seededAt > bankedConfirmedAt`). When `seedNewer` is set, the citation flips to **RE-CONFIRM** — the seed may carry a reclassification the banked entry predates, exactly the grok-4.5 case (seed demoted 2026-07-22, banked confirmed 2026-07-19). This changes the *signal*, not the *resolution*: the banked entry still wins the tier (rule 7 precedence, and the human is the only thing that re-banks) — it just stops the loop from silently trusting a classification the seed already superseded.

package/skills/engineering/harness-runtime/release-check.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const WEEK_MS = 7 * DAY_MS;
+const here = dirname(fileURLToPath(import.meta.url));
+
+function readJson(path, fallback = {}) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return fallback; }
+}
+
+function frontmatterValue(text, key) {
+  const frontmatter = /^---\n([\s\S]*?)\n---/.exec(text)?.[1] ?? '';
+  const match = new RegExp('^' + key + ':\\s*([^\\n]+)$', 'm').exec(frontmatter);
+  return match?.[1].trim().replace(/^['"]|['"]$/g, '') ?? null;
+}
+
+function repositoryOf(source) {
+  const value = String(source ?? '').trim();
+  const match = /^(?:git@github\.com:|https:\/\/github\.com\/)?([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?$/.exec(value);
+  return match?.[1] ?? null;
+}
+
+function stableVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(String(value ?? '').trim());
+  return match ? match.slice(1).map(Number) : null;
+}
+
+function newer(left, right) {
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] > right[index];
+  }
+  return false;
+}
+
+function writeCache(path, value) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(value));
+  } catch { /* A read-only cache must not block skill use. */ }
+}
+
+function main(now = Date.now()) {
+  if (process.env.ONEABOVEIO_NO_UPDATE_CHECK) return;
+  const skill = readFileSync(join(here, 'SKILL.md'), 'utf8');
+  const name = frontmatterValue(skill, 'name');
+  const localVersion = stableVersion(frontmatterValue(skill, 'release-version'));
+  if (!name || !localVersion) return;
+
+  const lock = readJson(join(process.env.HOME || homedir(), '.agents', '.skill-lock.json'));
+  const entry = lock.skills?.[name];
+  const repository = repositoryOf(entry?.sourceUrl || entry?.source);
+  if (!repository) return;
+
+  const cacheRoot = process.env.XDG_CACHE_HOME || join(process.env.HOME || homedir(), '.cache');
+  const cachePath = join(cacheRoot, '1aboveio-skills', 'release-check.json');
+  const all = readJson(cachePath);
+  const cache = all[repository] && typeof all[repository] === 'object' ? all[repository] : {};
+
+  if (!cache.lastCheck || now - cache.lastCheck >= DAY_MS) {
+    const result = spawnSync('gh', ['api', 'repos/' + repository + '/releases/latest', '--jq', '.tag_name'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1500,
+    });
+    cache.lastCheck = now;
+    if (result.status === 0 && stableVersion(result.stdout)) cache.latestTag = result.stdout.trim();
+    else delete cache.latestTag;
+    all[repository] = cache;
+    writeCache(cachePath, all);
+  }
+
+  const latestVersion = stableVersion(cache.latestTag);
+  if (!latestVersion || !newer(latestVersion, localVersion)) return;
+  if (cache.notifiedTag === cache.latestTag && cache.notifiedAt && now - cache.notifiedAt < WEEK_MS) return;
+
+  cache.notifiedTag = cache.latestTag;
+  cache.notifiedAt = now;
+  all[repository] = cache;
+  writeCache(cachePath, all);
+  const command = `npx skills@1.5.23 add '${repository}#${cache.latestTag}' --global --agent universal claude-code --skill ${name} --yes`;
+  process.stdout.write(
+    `UPDATE_AVAILABLE: A newer 1AboveIO skills release (${cache.latestTag}) is available; this skill is `
+      + `v${localVersion.join('.')}. Ask once whether to refresh ${name}. On approval run \`${command}\`. `
+      + 'The refreshed instructions apply next session. Either way, continue the current task and do not ask again this session.\n',
+  );
+}
+
+try { main(); } catch { /* Update checks are advisory and always fail silent. */ }

package/skills/engineering/resolve-issues/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+Copyright (c) 2026 1AboveIO