@starci/eslint-grammar-offset-pop 0.12.13 → 0.13.0

package/runtime/modules/models/registry.yaml

@@ -0,0 +1,221 @@
+schema: starci/profile-registry@1
+purpose: >-
+  The ONE model catalog of the runtime. Concrete model ids — provider,
+  capability tier and per-token price — live under `models`; the provider
+  quota/capacity pools, their roles and concurrency live under `pools` (which
+  model takes which work is modules/models/tiers.yaml); every launch target lives under `targets`, carrying
+  `defaultModel` where it names a single model. No other file in the repo
+  states a model id, tier, price or pool: those cite these keys.
+
+# Canonical naming. Keep these roles distinct
+# in contracts and receipts; an `agent` and a `provider` may carry the same
+# string, but the fields are not interchangeable — `agent` names the execution
+# adapter while model-routing `provider` remains quota authority.
+glossary:
+  launcher: human chat surface explicitly selecting the StarCi entry (codex-chat | claude-chat | devin-chat)
+  host: Orca execution environment owning terminals, worktrees and managed operation workers
+  agent: execution adapter / Orca agent id (codex | claude | devin | cursor)
+  provider: credential, billing and quota family used by allocation
+  model: a concrete model id (a `models` key below) that worker-start --model takes
+  target: a StarCi routing/capability target (a `targets` key below)
+  pool: one provider quota/capacity window (a `pools` key below), routed to as a target
+
+# Price table that turns measured token counts (llm_usage, scripts/lib/llm-usage.mjs
+# priceOf/costOfRow) into cost_usd. The runtime never guesses a price: a model absent
+# from `models`, or with a null rate, leaves cost_usd NULL. Nothing reads a provider
+# price feed; the owner declares the rates below from the provider's own price page
+# and dates the edit (pricing.asOf).
+pricing:
+  currency: USD
+  unit: per-million-tokens
+  asOf: '2026-10-03'
+  source: >-
+    Official list prices read 2026-09-29 (WebFetch): claude-* from https://claude.com/pricing (5-minute cache write TTL);
+    gpt-6-luna from https://developers.openai.com/api/docs/pricing. GPT-6.1 Sol list prices read 2026-10-03 from
+    https://developers.openai.com/api/docs/models/gpt-6.1-sol: Standard processing tier, contexts at or below 272K
+    tokens (input 2, output 10, cached input 0.10 per 1M tokens). Larger-context and other processing-tier multipliers
+    are not applied because the CLI reports no billing tier. swe-2-max (Devin) has
+    no official per-token price page read, so its rates stay null and cost_usd stays NULL for it. A subscription seat
+    (Claude Max, Codex Pro, Devin plan) bills a flat fee, so cost_usd is the API-equivalent list price.
+  matching: >-
+    priceOf(model): the exact `models` key first, then the longest declared id that is a prefix of the model
+    (a dated snapshot id `claude-opus-5-5-20260901` prices as `claude-opus-5-5`). The four rates are USD per 1M tokens:
+    input = fresh (non-cached) input, cacheRead = cached input read, cacheWrite = cache creation, output = generated
+    tokens including reasoning. A model whose used rate is null gets cost_usd NULL (a partial sum is never written).
+
+# The concrete model ids the runtime may name: provider (quota family), tier (the
+# capability class the catalog assigns it) and the per-token price row costOfRow
+# consumes. A launch-only target's `targets.<t>.defaultModel` and every pool's
+# `pools.<p>.models`/`defaultModel` pin keys of this map — nothing else.
+models:
+  claude-opus-5-5:   {provider: claude, tier: frontier, price: {input: 4,   output: 20,  cacheRead: 0.2,  cacheWrite: 5,     source: official}}
+  claude-sonnet-5-5: {provider: claude, tier: standard, price: {input: 2,   output: 10,  cacheRead: 0.2,  cacheWrite: 2.5,   source: official}}
+  gpt-6.1-sol:       {provider: codex,  tier: frontier, price: {input: 2,   output: 10,  cacheRead: 0.1,  cacheWrite: 2.5,   source: official}}
+  gpt-6-luna:        {provider: codex,  tier: economy,  price: {input: 0.1, output: 0.5, cacheRead: 0.01, cacheWrite: 0.125, source: official}}
+  swe-2-max:         {provider: devin,  tier: frontier, price: {input: null, output: null, cacheRead: null, cacheWrite: null, source: unset}}
+
+# The provider quota/capacity pools the allocator serves. Which model a seat or operation takes is
+# modules/models/tiers.yaml; `defaultModel` is the model a launch takes when it names none. `maxParallel` is
+# the only concurrency authority (registry.yaml executionModel.concurrency).
+pools:
+  # One Codex account window carries every Codex model. Role, tool and quality gates still apply on top of tier
+  # membership; an owner allocation changes capacity, never qualification or effect authority.
+  codex-agent:
+    target: codex-agent
+    provider: codex
+    roles: [implement, verify, write, decide, plan]
+    maxParallel: 10
+    defaultModel: gpt-6-luna
+  # One Claude session/week window, all five roles. The Claude CLI lists no models, so the dispatch's model
+  # attestation is what proves the model id a tier member names.
+  claude-agent:
+    target: claude-agent
+    provider: claude
+    roles: [implement, verify, write, decide, plan]
+    maxParallel: 6
+    defaultModel: claude-opus-5-5
+  # Devin has no machine-readable account headroom equivalent to Orca's provider windows. Owner-assigned
+  # capacity: 10 parallel lanes, opened by the owner's default grant (config.yaml allocation.grants
+  # devin-agent=10@implement+verify+write applies to every workflow; once config.yaml declares a grants list,
+  # `starci kernel route` rejects a grant-gated pool that list does not open). The CLI's auth/readiness and observed
+  # launch/refusal status are the live capacity signal on top of this cap.
+  devin-agent:
+    target: devin-agent
+    provider: devin
+    roles: [implement, verify, write]
+    maxParallel: 10
+    capacityAuthority: explicit-workflow-quota
+    quotaTelemetry: launch-status
+    defaultModel: swe-2-max
+
+runtimes:
+  - codex
+  - claude
+  - devin
+  - cursor
+aliases:
+  openai: codex
+  anthropic: claude
+  cognition: devin
+executionModel:
+  # Two agent levels, one host. A chat submits the goal and then monitors; it is
+  # never an agent layer above the kernel.
+  levels: [workflow-kernel, operation-agent]
+  host: orca
+  chat: trigger-and-monitor-only
+  workflowKernel: one-long-lived-agent-per-workflow
+  kernelAuthority: sole-workflow-state-writer-through-scripts/kernel/cli.mjs
+  operationAgent: one-ephemeral-agent-per-job
+  operationMapping: one-operation-instance-one-agent
+  isolationBoundary: operation
+  worktree: isolated-child-per-job
+  scheduling: dependency-dag
+  fanOutWithinOperation: forbidden
+  concreteAgentBinding: provider-profile-model
+  # Concurrency is one number per pool and it lives in one file.
+  concurrency: modules/models/registry.yaml pools.<pool>.maxParallel
+orchestration:
+  runtime: orca
+  owner: source-host
+  defaultOperationTarget: devin-agent
+  workspaceRouting: .workspaces/projects/<project>/work.json
+  # Owner ruling: owner gates are the StarCi entry's scope-bound acceptance
+  # for goal definition and native workflow startup, plus settle-time evidence verdicts — there is no
+  # separate approvals engine or policy file.
+  approvalMode: entry-skill-owner-ok
+  dispatch: The native lifecycle claims an accepted queued goal and spawns that workflow's one long-lived kernel agent
+    (scripts/kernel/start-workflow.mjs). The kernel is the sole workflow-state writer; `starci kernel dispatch --spawn`
+    launches one isolated agent per ready operation in the workflow's one worktree, using the first eligible target in
+    that operation's chain. The kernel never implements, repairs or tests on behalf of an operation agent.
+targets:
+  # Pool targets are named by a `pools` key above, whose `models` map pins the launch model per
+  # difficulty and whose `defaultModel` covers an unpinned difficulty. A pool target names no model itself.
+  codex-agent:
+    runtime: codex
+    orcaLaunch: {agent: codex}   # orca orchestration worker-start --agent codex
+  # Launch-only targets: an explicit `--model gpt-6.1-sol` or `--model gpt-6-luna` request reaches that one model
+  # on the Codex provider window. They are off every automatic chain; allocation routes the codex-agent pool.
+  # `defaultModel` is the launch model resolveWorkerLaunchModel returns for them (they hold no pools entry).
+  gpt-6.1-sol:
+    runtime: codex
+    defaultModel: gpt-6.1-sol
+    orcaLaunch: {agent: codex}   # orca orchestration worker-start --agent codex
+  gpt-6-luna:
+    runtime: codex
+    defaultModel: gpt-6-luna
+    orcaLaunch: {agent: codex}   # orca orchestration worker-start --agent codex
+  # Cursor: Orca agent id `cursor` (binary cursor-agent). A launch-only target like gpt-6.1-sol: off every automatic chain,
+  # reached by an explicit `--model auto` (the CLI's default) or any id of the account's `cursor-agent --list-models`.
+  # Live proof 2026-10-02: worker-start --agent cursor --model auto reached worker_done and released cleanly. No Cursor
+  # quota probe exists, so no automatic chain routes to it. `defaultModel: auto` is the CLI's selector keyword —
+  # Orca's catalog default — not a `models` entry (Cursor publishes no fixed priced catalog).
+  cursor-agent:
+    runtime: cursor
+    defaultModel: auto
+    orcaLaunch: {agent: cursor}   # orca orchestration worker-start --agent cursor
+  claude-agent:
+    runtime: claude
+    orcaLaunch: {agent: claude}   # orca orchestration worker-start --agent claude
+  devin-agent:
+    runtime: devin
+    executionHosts: [orca]
+    orcaLaunch: {agent: devin}   # orca orchestration worker-start --agent devin
+fallback:
+  allowedReasons:
+    - unavailable
+    - quota-exhausted
+    - rate-limited
+    - startup-failure
+    - unsupported
+  requiredEffectState: none
+  blockedReasons:
+    - permission-denied
+    - user-checkpoint
+    - business-ambiguity
+    - safety-block
+    - partial-or-unknown-effects
+selection: |-
+  Orca supplies the observed external-agent inventory. The tier chain (modules/models/tiers.yaml) names the
+  candidates; a member is taken only when it passes the picker's hard filter and has tokens (scripts/lib/tier-pick.mjs).
+  A launch falls to the next member only after an allowed failure with verified no-effect state. This policy never
+  installs an agent, authenticates a provider, grants tools or expands the workflow authority. Every member launches
+  the one way (modules/kernel/start-workflow.yaml): `orca orchestration worker-start --agent
+  <runtime> [--model <id> --effort <level>] --spec <prompt>` (Orca files the Task), the unattended flags from Orca's per-agent
+  default args; the launcher takes the agent terminal from the start receipt (else worker-show) and attests the effective agent and model
+  (worker-show). Devin takes no model flag (Orca: --model is for Claude, Codex and Cursor) and starts on its CLI default.
+costPolicy: |-
+  Runtime pools are provider quota windows. Which model takes which seat or operation is modules/models/tiers.yaml:
+  a seat or an op difficulty names a tier, a tier is an ordered member chain, and the picker takes the first member
+  with tokens after the owner bias and the balance step. Devin opens through the owner's default grant (config.yaml
+  allocation.grants). Drawing and artwork ops (interface.draw, interface.asset, brand.decide) take the tier of their
+  difficulty like every core op and make images through the headless `starci work imagegen` call, which is picked from the
+  imagegen call tier (tiers.yaml calls, tierUse) and holds one provider slot while it runs. Every automatic launch contains only worker-start candidates and advances only
+  after a verified no-effect failure. Agents have explicit turn, wall-time and tool-call ceilings; a ceiling stop is a
+  failed attempt and never proof of completion. Never infer price or quality superiority from a subscription label;
+  a tier change is proposed only on live ledger evidence: `starci machine op-metrics --by op` (success rate, retry
+  chains and repeated failures per op) and the ledger view `v_model_scorecard` (pass rate and tokens per op, agent
+  and model). A native worker is released
+  after its exact worker_done result is accepted; the workflow child remains until integration is complete.
+assetFallback: When image generation is unavailable, reuse verified assets first; Claude may leave
+  decorative image slots blank with a concrete deferred brief. Never mark missing artwork generated
+  or satisfy a functional criterion with a blank slot.
+examples:
+  codexFrontend:
+    runtime: codex
+    profile: gpt-6.1-sol
+    model: gpt-6.1-sol
+    imageGenerationAvailable: true
+  claudeFrontend:
+    runtime: claude
+    profile: opus
+    model: claude-opus-5-5
+    imageGenerationAvailable: false
+  orcaInterfaceImplementation:
+    skill: starci
+    op: interface.implement
+    availableRuntimes:
+      - codex
+      - claude
+examplesNote: Examples of frontend context.execution only. Set availability from observed host
+  tools, never copy true as proof. Declared exact models still require effective runtime attestation.
+  Orca resolves ordered skill/operator candidates from observed readiness instead.