omp-llm-role 1.1.0 → 1.3.0

package/docs/dev/explorer.md

@@ -12,7 +12,9 @@ explorer never reimplements `value = q − λ·$/M`.
 | File | Role |
 |---|---|
 | `src/explorer/server.ts` | Zero-dependency `node:http` surface: static SPA + JSON API. Exports `createExplorerServer`, `ExplorerOpts`. |
-| `src/explorer/explain.ts` | Pure explanation layer (no I/O): rank rows with baseline deltas, per-model decomposition, inverse-cardinal targets, and the keyed-catalog availability overlay. Exports `rankRows`, `explainModel`, `inverseCardinal`, `METRIC_META`, `WEIGHTABLE_METRICS`. |
+| `src/explorer/explain.ts` | Pure explanation layer (no I/O): rank rows with baseline deltas, per-model decomposition, inverse-cardinal targets, the keyed-catalog availability overlay, and the display-only per-task price. Exports `rankRows`, `explainModel`, `perTaskPrice`, `inverseCardinal`, `METRIC_META`, `WEIGHTABLE_METRICS`. |
+| `src/explorer/levers.ts` | Pure price-lever readouts (no I/O): the leader-flip threshold and the thinking level's effect on the leader, computed on the pool they are handed. Exports `leaderFlip`, `thinkingLevelEffect`, `LeaderFlip`, `ThinkingLevelRow`. |
+| `src/explorer/pool.ts` | The as-written pool (no I/O): the dataset filtered exactly as the updater filters it before ranking (catalog/tier gate + allowed-providers prune). Exports `asWrittenPool`, `PoolMode`, `PoolInputs`. |
 | `src/explorer/scopes.ts` | Scope resolution (no HTTP): the user-level scope, the registry's projects, and the session's project; the per-scope read; the dataset union. Exports `Scope`, `resolveScopes`, `defaultScopeId`, `resolveScope`, `readScopeRoles`, `unionRoles`. |
 | `src/explorer/boot.ts` | Shared launcher: bind/port fallback, scope resolution, browser open, close. Exports `startExplorer`, `EXPLORER_DEFAULT_PORT`, `ExplorerHandle`, `ExplorerBootOpts`. |
 | `src/project-registry.ts` | The global project registry (`llm-role-projects.json` in the agent dir): read/register/prune, atomic write. Exports `PROJECT_REGISTRY_FILE`, `readProjectRegistry`, `registerProject`. |
@@ -47,12 +49,29 @@ type ExplorerOpts = {
     availability: KeyAvailability;            // keyed-catalog overlay (re-derived on refresh)
   };
   refresh(): Promise<void>;                   // re-runs loadRankData({ refresh: true, roles, extraMetrics }) and swaps rank
+  // The as-written pool's inputs: the omp catalog, the key's tier, and the
+  // account's allowed-providers whitelist (null = no whitelist / harvest failed,
+  // which leaves every route in place). Re-derived per call, so a project's
+  // whitelist cannot leak into another scope's view.
+  getPoolInputs(): PoolInputs;
+  // The recorded usage rows the per-task price resolves its token profile from,
+  // for the request's active scope (a project scope reads its own `<root>/.omp`
+  // ledger). Optional: a host without a ledger supplies none.
+  getUsageRows?(scope: Scope): readonly UsageRow[];
+  // The user-set token profile the per-task column falls back to (the
+  // `tokenProfile` setting); null (the default) = unset.
+  tokenProfile?: TokenProfile | null;
 };
 ```
 
-The server holds the active scope id as mutable state (alongside the mutable
-`rank`/`availability`); `activeScope` resolves it per request, persisting the
-fallback when the active scope became unavailable.
+The server holds the active scope id **and the pool mode** as mutable state
+(alongside the mutable `rank`/`availability`); `activeScope` resolves the scope
+per request, persisting the fallback when the active scope became unavailable.
+`poolRank` applies the session's pool mode to the dataset before ranking — the
+`as-written` mode runs `asWrittenPool(rank, opts.getPoolInputs())`, the `raw`
+mode (the default, the historical behaviour) passes the fetch through. The pool
+mode is **never** applied to the export path, which validates a pin against the
+raw dataset.
 
 Endpoints:
 
@@ -62,8 +81,9 @@ Endpoints:
 | `GET /app.js`, `/style.css` | — | static asset (traversal-guarded) |
 | `GET /api/bootstrap` | — | `bootstrapPayload(opts, activeScope)` |
 | `POST /api/scope` | `{scope}` | switch the active scope, then the bootstrap payload (404 unknown id, 409 non-present) |
-| `POST /api/rank` | `{role, def}` | `{eligible, lambda, derivedLambda, rows, errors}` |
-| `POST /api/explain` | `{role, def, modelId}` | `explainModel(...)` spread + `errors` |
+| `POST /api/pool` | `{mode}` | switch the ranked pool (`"raw"` \| `"as-written"`), then the bootstrap payload (400 on any other mode) |
+| `POST /api/rank` | `{role, def}` | `{eligible, lambda, derivedLambda, rows, errors}` — each row carries the display-only `perTask` |
+| `POST /api/explain` | `{role, def, modelId}` | `explainModel(...)` spread + `leaderFlip` + `thinkingLevels` + `errors` |
 | `POST /api/export` | `{roles}` | `{ok:true, backupPath, roles, lockPath}` or `{ok:false, errors}` |
 | `POST /api/refresh` | — | `await opts.refresh()` (re-ranks and re-derives the availability overlay) then the bootstrap payload |
 
@@ -75,7 +95,9 @@ Endpoints:
   focus metrics over the resolved dataset), `levels` (`Object.keys(SUFFIX_LEVELS)`), `thinkingFactors`
   (per-level billed-blend multiplier from the engine's own `thinkingPriceFactor`,
   so the UI readout cannot drift), `fetchedAt`, `modelCount`, `orMatched`,
-  `orPriced`, `lockPath` (the **active scope's** lock file), `scopes` (id, label,
+  `orPriced`, `poolMode` (the ranked pool the counts describe — `"raw"` or
+  `"as-written"`), `tokenProfile` (the user-set per-task token profile, or
+  `null`), `lockPath` (the **active scope's** lock file), `scopes` (id, label,
   kind, present per known scope), `activeScope` (the active scope id),
   the active scope's global capability flags and the feature registry (the
   `FEATURES` rows: id, label, description, recommended bundle, buys), so the SPA
@@ -99,8 +121,12 @@ Endpoints:
   expansion the preview would omit the preset the baseline includes and every
   row's Δ would be a lie. The posted def is the **authored** def (flags + explicit
   keys); the expansion is applied only for the ranking call, never persisted.
-- `handleExport` calls `writeRoleSettings(activeScope.lockPath, body.roles)` and
-  returns its result verbatim plus the written `lockPath`.
+- `handleExport` validates every dirty role first — `validateRole` plus a
+  **provider-pin check**: a `providerPin` that matches no route in the loaded
+  dataset is rejected (`role "<name>": provider pin "<slug>" matches no route in
+  the loaded dataset`) before any write, so an exported role cannot carry an
+  unroutable pin. It then calls `writeRoleSettings(activeScope.lockPath,
+  body.roles)` and returns its result verbatim plus the written `lockPath`.
 - Unknown `/api/*` → 404; wrong method → 405; non-API non-GET → 405.
 - `readBody` caps at `MAX_BODY = 1 MiB` (413); `readJson` → 400 on invalid JSON.
 - `serveStatic` resolves against `webDir` and rejects traversal (`full` must be
@@ -120,33 +146,67 @@ Pure, no I/O; all ranking math is delegated to `src/engine.ts`.
   declared?)`** merges the shipped table with a derived entry per external metric.
 - **`weightableMetrics(extra?)`** — the shipped keys plus any external metric in
   `extra`; exactly what the validator accepts.
-- **`rankRows(def, models, baseline, availability?)`** — `rankRole(def, models)` +
+- **`rankRows(def, models, baseline, availability?, profile?)`** — `rankRole(def, models)` +
   `paretoFrontier`, annotating each row with `baselineRank`/`delta`
   (`baselineRank − rank`; positive = moved up) against the effective role's
   ranking. Rows carry `priceEff` (the thinking-adjusted price the ranking
   penalized), `parts`, `missing` (weighted non-price metrics whose raw value is
-  null), `frontier`, and `key` — the availability overlay verdict
+  null), `frontier`, `key` — the availability overlay verdict
   (`usable`/`blocked`/`unknown`), orthogonal to `missing` and to the eligibility
-  gates. `availability` is optional and pure (no I/O); omitted or inactive ⇒
-  every row reads `unknown`.
+  gates — and `perTask` (the display-only dollars-per-task, or `null`).
+  `availability` and `profile` are optional and pure (no I/O); omitted or
+  inactive ⇒ every row reads `unknown` / `perTask: null`. Neither affects the
+  ranking order or the deltas.
 - **`inverseCardinal(metric, t)`** — inverse of `cardinalMetric` for the "what
   would it take" targets: `index` → `t*80 − 20`; `throughput` → `10 * 30**t`
   (null outside `[0,1]`, because the forward transform clamps); everything else
   (benchmark, percentile, price) → identity. See *Open defect* below for the
   `gpqa` exception.
-- **`explainModel(def, models, modelId, roleName, availability?)`** — the full
+- **`perTaskPrice(model, def, profile)`** — the display-only dollars-per-task:
+  `p_in` is the role's priced route's input price (cache-adjusted by the role's
+  `cacheHitRate`, `routeInputPrice`) and `p_out` that same route's output price —
+  the inverse 3:1 blend of it (`routeOutputPrice`), never re-derived here — and
+  the output term is scaled by the role's thinking factor
+  (`thinkingAdjustedPrice(model, def, 1)`, so the per-task price and the row's
+  `priceEff` cannot disagree). When the role prices on the `1/price²` blend
+  (`roleRoute` returns `null`) the model's billed blend and the input blend over
+  the routes that survive the role's endpoint filters stand in — the same pool the
+  ranking prices on, so `p_in` and the billed blend never mix two route pools.
+  `null` when there is no usable route price — **absent, never a silent
+  zero**. The SPA renders `—` in both cases: no token profile resolves (no
+  recorded usage and no `tokenProfile` set), **or** the model has no usable
+  route price (e.g. every route pruned by the as-written whitelist — the model
+  still ranks on its blend price, but the per-task column has no route to
+  price). It never feeds the ranking's sort key, `value`, or the explanation's
+  `cost` block.
+- **`explainModel(def, models, modelId, roleName, availability?, profile?)`** — the full
   decomposition, or the eligibility gates it failed (same gates `rankRole`
   applies, same order: missing required, image filter, no billed price). On
   success: `contributions`
   (raw → cardinal `t` → renormalized weight → contribution → share of `q`, with
   a `fillNote` when the value is a capability fill), `cost` (`priceEff`, the
   cache-adjusted billed price, λ, penalty, `q`, `value`), `role.cacheHitRate`,
-  `gapAbove`/`gapToTop`/`above`, `closing` (the
+  `perTask` (the `PerTaskPrice` breakdown, or `null` when no profile was
+  supplied or the model has no usable route price), `gapAbove`/`gapToTop`/`above`, `closing` (the
   per-metric raw target that would close the gap, via `inverseCardinal`, with
   unreachable/extrapolated notes), `dominators` (models both cheaper and at
-  least as good on `q`, top 3), and the availability overlay `key`/`keyReason`
+  least as good on `q`, top 3), `ownProvider` (true when the model was priced on
+  the soft best route rather than the blend), `autoPin` (the provider slug the
+  updater would write — `bestRoute(model, def)?.providerSlug`, the max-`vfm`
+  route (scoring.md, *Route ordering*), when the role sets
+  `preferOwnProvider` and carries no manual `providerPin`, else `null`), and the
+  availability overlay `key`/`keyReason`
   (the same verdict as `rankRows`, plus the reason it reads that way). It mirrors
   `rankRole`'s capability fill so the contributions sum exactly to `q`.
+- **`leaderFlip(def, models)`** / **`thinkingLevelEffect(def, models)`**
+  (`src/explorer/levers.ts`) — the two price-lever readouts, computed on the pool
+  they are handed (so the readout and the ranking above it agree). `leaderFlip`
+  returns the price weight at which a cheaper challenger overtakes the value
+  leader (`{ wPrice, flipW, distance, challenger }`), or `null` when no cheaper
+  challenger exists. `thinkingLevelEffect` returns one `{ level, factor, leader }`
+  row per thinking level, or `null` for a bare role. Both reuse the engine's own
+  `roleLambda`/`rankRole`/`SUFFIX_LEVELS`/`thinkingPriceFactor`; the formulas are
+  in [`scoring.md`](scoring.md).
 
 ## Shared boot path (`src/explorer/boot.ts`)
 
@@ -193,6 +253,22 @@ launcher `/explore-roles` uses.
   factor on the omp catalog; `refresh()` re-runs `opts.reload(true)`,
   re-enriches, and — when `opts.reloadAvailability` is supplied — re-derives the
   availability overlay.
+- **As-written pool inputs.** `ExplorerBootOpts` carries `tier` (default
+  `"billed"`), `allowedProviders` (`null` = no pruning), and
+  `reloadAllowedProviders` (re-derived on `refresh()`). `getPoolInputs()` returns
+  `{ catalog: opts.catalog, tier, allowed }` per call, so a project's whitelist
+  cannot leak into another scope's view. Both are **best-effort**: an absent tier
+  reads as `billed`, and a failed re-harvest (`reloadAllowedProviders` throwing
+  or returning `null`) degrades the as-written pool to no route pruning rather
+  than failing the refresh. `/explore-roles` builds them in-process from the
+  session's OpenRouter key (the canary must be a **catalog** slug, not a ranking
+  id).
+- **Usage ledger.** `getUsageRows(scope)` reads the active scope's ledger: a
+  project scope reads its own `<root>/.omp` ledger, the user scope reads
+  `usageDir` (default `agentDir()`), so a project's usage never mixes with the
+  user-level profile. Re-read per call, so a turn recorded while the explorer is
+  open shows up without a restart. `tokenProfile` is the user-set fallback the
+  per-task column uses when a role has no recorded usage.
 - `opts.availability` is the boot-time keyed-catalog overlay; `getState(scope)`
   returns it on every request, so `/api/rank` and `/api/explain` annotate rows
   without a second fetch. It is scope-independent and carried across switches
@@ -237,12 +313,23 @@ a scraped third-party site, so the DOM is built with
 `textContent`/`createElement` only (the `el()` helper).
 
 - **Boot**: `boot()` → `GET /api/bootstrap` → `applyBootstrap(data)`, which fills
-  `state` (`scopes`, `activeScope`, `universe`, `effective` = each entry's `def`,
+  `state` (`scopes`, `activeScope`, `poolMode`, `tokenProfile`, `universe`,
+  `effective` = each entry's `def`,
   `defs` = a structuredClone of it, `defaults`, `metrics`, `metricMeta`,
   `focusAssessments`, `levels`, `thinkingFactors`, `lockPath`, `availability`),
   renders the header/roles/table, and selects the previously selected role when
   the new scope has it, else the first role. `boot()` then wires the
   filter/topn/hide-key-blocked/export/copy/download controls.
+- **Pool toggle**: the header renders a `#pool` `<select>` (`raw` / `as-written`)
+  from `state.poolMode`. Changing it confirms first when there are unsaved edits
+  (mirroring the scope switcher), then `POST /api/pool {mode}` and
+  `applyBootstrap` on the returned payload — so the header's model count, the
+  table, the focus assessments and the two readouts all describe the pool the
+  user is now looking at. The toggle is **session-level** state — the server
+  holds one pool mode, kept across scope switches (not persisted) — while the
+  pool *inputs* are re-derived per call, so a project's whitelist never leaks
+  into another scope's view. Export is unaffected: it always
+  writes the authored def, never the pool.
 - **Scope switcher**: the header renders a `#scope` `<select>` from
   `state.scopes` (the user-level scope plus every known project); a scope whose
   lock file is gone is `disabled` with a reason `title`. Changing the selection
@@ -273,11 +360,29 @@ a scraped third-party site, so the DOM is built with
 - **Recompute**: `selectRole` → `renderRoles`/`renderEditor`/`renderExplain` +
   `recompute()`. `recompute()` → `POST /api/rank {role, def}` → `state.rows`,
   `lambda`, `derivedLambda`, `errors`; re-renders the table and readouts, and
-  reloads the explain panel if the selected model is still present. Editor
-  changes call `scheduleRecompute()` (120 ms debounce).
+  reloads the explain panel if the selected model is still present. The table
+  gains a **`$/task`** column (`r.perTask`, rendered `—` when `null`), beside the
+  `$/M` column. Editor changes call `scheduleRecompute()` (120 ms debounce).
 - **Explain**: `selectModel(id)` → `POST /api/explain {role, def, modelId}` →
-  `renderExplain()` (composition table, cost line, "why not higher",
-  dominators, and the availability line).
+  `renderExplain()` (composition table, cost line, **per-task price** line, "why
+  not higher", dominators, the **Price levers** section, and the availability
+  line). The cost line appends `· best route`
+  when the model was priced on the soft best route (`ownProvider`), and a
+  **pin line** shows the pin in force: `pin: <slug> (manual)` when the edited def
+  carries a `providerPin`, else `auto pin: <slug>` from the explanation's
+  `autoPin` (read-only — the manual field is the only way to set one). The
+  per-task line shows the breakdown (`<in> in × $<p_in>/M + <out> out ×
+  $<p_out>/M × <factor> = $<total>`), or `— (no token profile — record usage or
+  set tokenProfile)` when `perTask` is `null`. The **Price levers** section
+  renders the leader-flip line (`w* = <flipW> · now <wPrice> · distance
+  <±distance> (<ratio>)`) and a per-level table of the thinking level's effect on
+  the leader; each is omitted when the server sends `null` (no cheaper
+  challenger, or a bare role).
+- **Provider pin field**: the editor renders a text input for
+  `roles.<role>.providerPin` (a tiered slug like `deepinfra/fp8` is kept
+  verbatim; empty clears the key, resuming the automatic choice). It is the
+  manual override of the auto-pin; Export rejects a slug that matches no route in
+  the loaded dataset (see *Export path*).
 - **Availability overlay**: each row's `key` renders as a three-state badge in
   the `key` column; the **hide key-blocked** checkbox beside the filter/top-n
   controls drops `blocked` rows from the table (a client-side filter — the

package/docs/dev/quirks.md

@@ -146,6 +146,22 @@ things that only bite someone changing or debugging the code.
   update (or a `link` to a changed tree), a session that was already running
   still executes the module it loaded at start; a write from that stale code can
   revert a newer write. Restart the session after updating the plugin.
+- **omp's restore-to-primary is silent to extensions.** After a fallback
+  cooldown, omp restores the primary model at prompt admission
+  (`#maybeRestoreRetryFallbackPrimary`) with **no** session event, and
+  `model_changed` is not delivered to extensions — so a display derived from the
+  fallback events alone would keep the fallback's provider pin after a restore.
+  The provider display (`src/provider-display.ts`) therefore re-derives the pin
+  from the live model on `turn_start`, which *is* extension-delivered and fires
+  after the restore. The same re-derive covers a manual `/model` change (with a
+  one-turn lag). The primary and a fallback may be the same registry object
+  (same model id, different route), so the strip-then-append is idempotent and
+  reads the pin from the live model's routing block, never a cached value.
+  `retry_fallback_applied`/`retry_fallback_succeeded` are also emitted for
+  **advisor** fallbacks, where only the advisor's model changes and the session
+  model is untouched, so the event's selector is trusted only when it names the
+  live session model (`liveModelIsSelector`); otherwise the pin is re-derived
+  from the live model's routing block.
 - **Testing a registered slash command needs `--mode rpc` or a TUI** — `omp -p`
   (print mode) sends a leading `/name` as a *prompt* to the model, so the handler
   never runs and `ctx.ui.notify` is a no-op anyway. RPC mode does dispatch them:
@@ -154,6 +170,22 @@ things that only bite someone changing or debugging the code.
   stderr; `get_available_commands` confirms registration. Verified this way for
   `/create-agent` and `/explore-roles` (omp 18.4.8).
 
+## Repository plumbing
+
+- **The https credential cannot *introduce* a workflow change.** `origin` is
+  https and its credential is a `gh` OAuth token with scopes
+  `admin:public_key, gist, read:org, repo` — no `workflow` — so a push that adds
+  or modifies `.github/workflows/*` is rejected ("refusing to allow an OAuth App
+  to create or update workflow … without `workflow` scope"), and the REST
+  contents API is rejected the same way. The check is a diff against the ref's
+  base, not a property of the ref: a new branch or tag whose commit already
+  contains the workflow, with `main` also containing it, pushes fine over https
+  (verified 2026-10-08). So only the commit that lands a workflow edit needs the
+  SSH route — `git push git@github.com:Gott50/omp-llm-role.git main` — and
+  because that bypasses the `origin` remote it leaves `refs/remotes/origin/main`
+  stale, which makes `scripts/release.ts cut` refuse ("HEAD is not origin/main")
+  until `git fetch origin` runs.
+
 ## Historical
 
 - **Bare roles were priced as if thinking were free** (fixed 2026-09-30).

package/docs/dev/releasing.md

@@ -116,14 +116,64 @@ path, plus `marketplace update` + `upgrade` to a bumped catalog version), and
 
 ## Status
 
-- **CI/CD landed 2026-10-08** (`fa7e546`): every pull request and every `main`
-  push runs the suite on GitHub (verified green on PR #57 and on the `main`
-  push), and a `v*` tag push publishes to npm over OIDC and creates the GitHub
-  Release. The guard was verified with a negative control — tag `v0.0.1`
-  against version `1.1.0` failed in `notes` before any publish. The first real
-  CD run still needs the one-time trusted-publisher registration and a route
-  for the legacy `v1.1.0` tag; see [`ci.md`](ci.md).
-- **1.1.0 cut 2026-10-08** (`c013918`, tagged `v1.1.0`). `package.json` and
+- **CI/CD landed 2026-10-08** (`fa7e546`, docs follow-ups `4f78ce2`, `1d20ef9`,
+  `9244fdc`, `3c0125a`): every pull request and every `main` push runs the suite
+  on GitHub (verified green on PR #57 and on the `main` pushes), and a `v*` tag
+  push publishes to npm over OIDC and creates the GitHub Release. The guard was
+  verified with a negative control — tag `v0.0.1` against version `1.1.0` failed
+  in `notes` before any publish.
+- **1.2.0 published by CD 2026-10-12** (run 38299141569, tag push): the guard
+  and the npm floor passed, `npm publish` completed over OIDC trusted publishing
+  with a provenance attestation (`npm audit signatures`: 1 package has a
+  verified attestation), and the GitHub Release was created with the 1.2.0
+  CHANGELOG section as its body
+  (`https://github.com/Gott50/omp-llm-role/releases/tag/v1.2.0`). Verified:
+  `dist-tags.latest` = `1.2.0`, npm's `gitHead` = `50fce66` (the tag's commit),
+  and the publish step's log carries the direct-publish signature (`Publishing
+  to https://registry.npmjs.org/ with tag latest`, `Signed provenance
+  statement`, `+ omp-llm-role@1.2.0`). The cut (`50fce66`, tagged `v1.2.0`)
+  bumped the four lockstep fields, renamed `## [Unreleased]` to
+  `## [1.2.0] - 2026-10-12`, and regenerated the report (408 models, matched
+  150/408, priced 148; `docs/dev/current-state.md` refreshed to the same
+  measurement).
+- **1.2.0 install routes smoke-tested** (2026-10-12, omp 18.10.3, throwaway
+  `HOME`s, cwd outside the real home tree): npm
+  (`omp plugin install omp-llm-role`), git
+  (`omp plugin install github:Gott50/omp-llm-role`) and marketplace
+  (`omp plugin marketplace add Gott50/omp-llm-role` +
+  `omp plugin install omp-llm-role@gott50-plugins`) each installed 1.2.0
+  (`omp plugin doctor`: 4 ok / 0 warnings / 0 errors for npm and git; the
+  marketplace install's one warning is the expected
+  `package_manifest: Not created yet`). Each post-install session run
+  (`omp -p "say ok"` with `OPENROUTER_API_KEY` from `omp token openrouter`)
+  wrote `modelRoles` (9 roles), `retry.fallbackChains` and
+  `task.disabledAgents: [designer]` into that HOME's `config.yml`, landed
+  `llm-role-state.json` + `llm-role-history.jsonl`, and answered. The npm-route
+  run also exercised the spec #65 whitelist harvest live (`OpenRouter
+  allowed-providers whitelist active — 11 providers; 542 routes pruned`).
+- **1.1.0 published by CD 2026-10-09** (run 37897647817,
+  `gh workflow run ci.yml --ref v1.1.0`): the guard and the npm floor passed,
+  `npm publish` completed over OIDC trusted publishing with a provenance
+  attestation (`npm audit signatures`: 0 invalid, 0 missing), and the GitHub
+  Release was created with the 1.1.0 CHANGELOG section as its body
+  (`https://github.com/Gott50/omp-llm-role/releases/tag/v1.1.0`). Verified:
+  `dist-tags.latest` = `1.1.0`, npm's `gitHead` = `4f78ce2` (the tag's commit),
+  `_npmUser` = `GitHub Actions` carrying the trusted-publisher OIDC config, the
+  provenance statement in the transparency log at
+  `https://search.sigstore.dev/?logIndex=3159690884`, and the tarball is 56
+  files / 308.4 kB. The `v1.1.0` tag was repointed to
+  `4f78ce2` first — its original commit predates the workflow file, so the
+  dispatch was rejected (see [`ci.md`](ci.md)).
+- **npm route smoke-tested for 1.1.0** (2026-10-09, omp 18.8.6, throwaway
+  `HOME`, cwd outside the real home tree): `omp plugin install omp-llm-role`
+  installed 1.1.0 from the registry (`omp plugin doctor`: 4 ok, 0 warnings,
+  0 errors) and the post-install session run (`omp -p "say ok"` with
+  `OPENROUTER_API_KEY` from `omp token openrouter`) wrote `modelRoles`
+  (9 roles), `retry.fallbackChains` and `task.disabledAgents: [designer]` into
+  that HOME's `config.yml`, landed `llm-role-state.json` +
+  `llm-role-history.jsonl`, and answered.
+- **1.1.0 cut 2026-10-08** (`c013918`, tagged `v1.1.0` — repointed to `4f78ce2`,
+  see the publish bullet). `package.json` and
   `.omp-plugin/marketplace.json` bumped in lockstep (plus `package-lock.json`
   via `npm install --package-lock-only` — the repo keeps it in lockstep, see
   `8811309`), `## [Unreleased]` renamed to `## [1.1.0] - 2026-10-08`, and the
@@ -141,26 +191,6 @@ path, plus `marketplace update` + `upgrade` to a bumped catalog version), and
   `modelRoles` (9 roles), `retry.fallbackChains` and
   `task.disabledAgents: [designer]` into that HOME's `config.yml`, landed
   `llm-role-state.json` + `llm-role-history.jsonl`, and the session answered.
-  The npm route has **not** been smoke-tested for 1.1.0 — it is still serving
-  1.0.0.
-- **npm publish pending a valid token.** The `~/.npmrc` token is rejected
-  (`npm whoami` → 401 "your authentication token seems to be invalid",
-  `npm publish` → 404 on `PUT /omp-llm-role`), so `omp-llm-role@1.1.0` is not
-  on the registry yet, `dist-tags.latest` still points at `1.0.0`, and **npm's
-  `gitHead` for 1.1.0 does not exist yet** — the tag currently stands on its
-  own. The token is the only credential source (no repo `.npmrc`, no
-  `/opt/homebrew/etc/npmrc`, no `NPM_TOKEN` in the environment or the shell
-  profiles, no keychain entry) and it is a literal value, not a `${NPM_TOKEN}`
-  indirection, so the cause is a rejected/revoked/expired token — **not** the
-  2026-07-31 GAT restriction, which covers account/org/package-management
-  actions and not `whoami`, and not direct publish either (that loss is
-  targeted January 2027). `npm ping` and `npm owner ls` still succeed because
-  they are unauthenticated reads. Fix: the release workflow — OIDC trusted
-  publishing, no token — once the trusted publisher is registered (see
-  [`ci.md`](ci.md)). The tag was cut before the publish (the documented order is
-  publish-then-tag) precisely so the pinned git ref and the changelog link
-  resolve meanwhile; that also means the tag's commit predates the workflow
-  file, so the workflow cannot be dispatched against it.
 - **1.0.0 on all three channels** (2026-10-03): `omp-llm-role@1.0.0` on npm
   (`dist-tags.latest` = `1.0.0`), tagged `v1.0.0` at `fe98b76` (npm's
   `gitHead`); all three routes verified end-to-end against the real URLs
@@ -169,7 +199,8 @@ path, plus `marketplace update` + `upgrade` to a bumped catalog version), and
   landed the three daily caches in the installed copy.
 - **Stray registry placeholder.** The registry also carries a `0.0.0-stage`
   version ("Temporary package placeholder for staged publishing", 334 B,
-  published 2026-10-03). It is not from this tree; `latest` still points at
-  `1.0.0`, so it does not affect installs.
-- **Next release: one owed.** `## [Unreleased]` carries the CI/CD entry; the
-  number comes from the Unreleased scope, not from the open issues.
+  published 2026-10-03). It is not from this tree and does not affect installs
+  (`latest` is `1.2.0`).
+- **Next release: none owed.** `## [Unreleased]` is empty — the 1.2.0 cut moved
+  its entries under `## [1.2.0] - 2026-10-12`; the number comes from the
+  Unreleased scope, not from the open issues.