sprag-cli 3.69.0 → 3.70.0

package/NOTICE

@@ -31,5 +31,8 @@ presets/korean-style/fluent-korean.md
 Trademarks
 
 Section 6 of the License grants no rights in the project's names or marks.
-"sprag" and the sprag logo are not licensed for use in a way that states or
-implies endorsement of a fork or a derived distribution.
+"sprag", the sprag logo and the domain sprag.io are not licensed for use in a
+way that states or implies endorsement of a fork or a derived distribution, or
+as the name of a fork, a modified build or a hosted service. The permitted uses
+are listed in TRADEMARK.md at the root of the repository
+(https://github.com/rootstudioyaml/sprag/blob/main/TRADEMARK.md).

package/README.ko.md

@@ -250,6 +250,16 @@ sprag feedback "Bedrock에서 5m TTL 칩이 사라지지 않아요"
 
 버그를 제보하실 때는 도구 버전(`sprag --version`)과 OS 를 함께 적어 주십시오. statusline 이나 경고 관련 문제라면 statusline 출력이나 `sprag last` 결과를 덧붙여 주시면 원인을 빨리 찾을 수 있습니다.
 
+## 팀
+
+Sprag 은 켜지 않으면 로컬에서만 동작합니다. `sprag team join <토큰>` 을 실행하거나(조직 전체는 `SPRAG_TEAM_TOKEN`) 하면 컴퓨터마다 하루에 한 행씩 올라갑니다. 내용은 지출, 절감액, 위임 실행 횟수, 모델 계열 비중입니다. 프롬프트, 대화 기록, 파일 경로, 프로젝트 이름은 보내지 않으며, `sprag team status --show-payload` 로 올라갈 내용을 그대로 볼 수 있습니다. 그 대신 팀 소유자는 대시보드에서 구성원별 합계를 보고, 모든 구성원에게 자동으로 적용될 래칫 룰을 승인할 수 있습니다.
+
+`CTS_NO_TEAM_SYNC=1` 은 팀 관련 통신을 모두 끄고, `sprag team leave` 는 참여를 해제합니다.
+
+- [팀 기능 안내](docs/TEAM.ko.md)
+- 대시보드: https://sprag.io/team/
+- 플랜과 가격: https://sprag.io/pricing/
+
 ## 라이선스
 
 Apache License 2.0 입니다. 원문은 [LICENSE](https://github.com/rootstudioyaml/sprag/blob/main/LICENSE) 에 있고, 그 라이선스가 요구하는 출처 표기는 [NOTICE](https://github.com/rootstudioyaml/sprag/blob/main/NOTICE) 에 정리했습니다.

package/README.md

@@ -304,6 +304,16 @@ It files a GitHub issue through the `gh` CLI when one is authenticated. Otherwis
 
 For a bug, please include the tool version (`sprag --version`) and your OS. For a statusline or warning issue, add the statusline output or the `sprag last` result.
 
+## Teams
+
+Sprag stays local unless you opt in. With `sprag team join <token>` (or `SPRAG_TEAM_TOKEN` for a whole organization), each machine uploads one row per day: spend, savings, delegated-run count and model-family share. Prompts, transcripts, file paths and project names are never sent, and `sprag team status --show-payload` prints exactly what would go up. In return the team owner sees per-member totals in a dashboard and can approve ratchet rules that every member picks up automatically.
+
+`CTS_NO_TEAM_SYNC=1` turns all team traffic off, and `sprag team leave` removes the membership.
+
+- [Team layer guide](docs/TEAM.md)
+- Dashboard: https://sprag.io/team/
+- Plans and pricing: https://sprag.io/pricing/
+
 ## License
 
 Apache License 2.0. The full text is in [LICENSE](https://github.com/rootstudioyaml/sprag/blob/main/LICENSE), and the attributions

package/bin/cli.js

@@ -102,7 +102,7 @@ function segmentsFromArgs() {
 const KNOWN_SUBCOMMANDS = new Set([
   'last', 'brief', 'history', 'handoff', 'install', 'uninstall', 'mode', 'korean', 'cohesion',
   'doc2md', 'delegate', 'harness', 'route-scan', 'compact-window', 'update-check', 'upgrade',
-  'seed', 'litellm-budget', 'profile-map', 'feedback', 'saved', 'cowork',
+  'seed', 'litellm-budget', 'profile-map', 'feedback', 'saved', 'cowork', 'team',
 ]);
 
 // Flags each entry path reads, collected from the hasFlag/getArg/numArg calls in
@@ -207,6 +207,7 @@ Usage:
   sprag update-check       is a newer version out?
   sprag brief --hook       internal: the UserPromptSubmit hook entry point
   sprag feedback "<msg>"   file a bug report / feature request (no browser needed)
+  sprag team create|join|status|sync|leave   opt-in team layer: daily aggregates only (CTS_NO_TEAM_SYNC=1 turns it off)
   sprag upgrade            install the latest release
   sprag --install-hook     install cache-monitor PostToolUse hook
   sprag --uninstall-hook   remove that hook
@@ -302,6 +303,12 @@ async function main() {
     return (await import('../src/commands/feedback.js')).run({ args, getArg, version: PKG_VERSION, dataDir: userDataDir() });
   }
 
+  // Subcommand: team — opt-in team layer (join with an invite token, daily
+  // aggregates only, team rules). See src/commands/team.js and src/team-sync.js.
+  if (args[0] === 'team') {
+    return (await import('../src/commands/team.js')).run({ args, hasFlag, getArg, version: PKG_VERSION });
+  }
+
   if (args[0] === 'handoff') {
     return (await import('../src/commands/handoff.js')).run({ getArg });
   }

package/docs/CODEX.ko.md

@@ -200,6 +200,7 @@ sprag delegate shared status --agent codex
 # 자동으로 정해진 난도별 모델을 바꾸고 싶을 때만:
 sprag delegate shared map T2 --from PARENT_MODEL --model SMALL_MODEL --effort high --agent codex
 sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort medium --agent codex
+sprag delegate shared map T1H --from PARENT_MODEL --model LARGE_MODEL --effort high --agent codex
 ```
 
 등록 전에 전역과 프로젝트 범위를 선택합니다. 프로젝트에만 적용하려면 `--global` 대신

package/docs/CODEX.md

@@ -302,6 +302,7 @@ sprag delegate shared status --agent codex
 # optional, to override the automatic tier models:
 sprag delegate shared map T2 --from PARENT_MODEL --model SMALL_MODEL --effort high --agent codex
 sprag delegate shared map T1 --from PARENT_MODEL --model MEDIUM_MODEL --effort medium --agent codex
+sprag delegate shared map T1H --from PARENT_MODEL --model LARGE_MODEL --effort high --agent codex
 ```
 
 The map lines are optional. A tier without a mapping resolves automatically,

package/docs/TEAM.ko.md

@@ -0,0 +1,119 @@
+# 팀 기능
+
+[← README](../README.ko.md) · [English](./TEAM.md)
+
+Sprag 은 기본적으로 로컬에서만 동작합니다. 팀 기능은 켜야만 쓰이는 선택 기능입니다. 팀원마다 하루 지출과 절감액을 한 대시보드에서 보고, 팀 소유자가 승인한 래칫 룰을 함께 쓸 수 있습니다. `sprag team join <토큰>` 을 실행하거나 환경에 `SPRAG_TEAM_TOKEN` 을 지정하기 전에는 아무것도 전송하지 않습니다. `CTS_NO_TEAM_SYNC=1` 을 지정하면 다른 설정과 상관없이 팀 관련 네트워크 통신이 모두 꺼집니다.
+
+## 보내는 것과 보내지 않는 것
+
+참여하면 Sprag 은 로컬 날짜 기준으로 하루에 한 행씩 올립니다.
+
+| 항목 | 내용 |
+|---|---|
+| 지출(USD) | 로컬 세션 로그로 계산한 금액 |
+| 절감(USD) | 라우팅 원장과 doc2md 원장에서 가져온 금액 |
+| 위임 실행 횟수 | 그날 위임한 실행의 수 |
+| 모델 계열 비중 | 위임 실행 중 모델 계열별 비율 |
+| Sprag 버전 | 설치된 버전 |
+| 에이전트 | `claude` 또는 `codex` |
+| 표시 이름 | 참여할 때 정한 이름이며, 기본값은 OS 사용자 이름 |
+
+보내지 않는 것은 프롬프트, 대화 기록, 파일 경로, 프로젝트 이름, 룰 내용, API 키입니다. 룰은 직접 `sprag team propose` 를 실행할 때만 밖으로 나갑니다.
+
+업로드는 6시간에 한 번 이하로 실행됩니다. SessionStart 훅이 띄운 분리된 자식 프로세스가 보내며, statusline 을 그리는 경로에서는 절대 실행되지 않습니다.
+
+목적지는 `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` 입니다(Supabase, ap-northeast-2 리전). 호출하는 RPC 는 `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose`, `team_leave` 입니다.
+
+## CLI에서 팀 만들기
+
+웹 대시보드 없이 팀을 만들 수 있습니다. 로그인은 메일로 받는 6자리 코드(15분간 유효)로 하며, Sprag 은 로그인 세션을 저장하지 않습니다.
+
+터미널에서는 명령 하나를 실행하고 묻는 대로 답하면 됩니다 (이메일, 코드, 팀 이름).
+
+```bash
+sprag team create
+```
+
+에이전트나 터미널이 없는 셸에서는 두 단계로 나눕니다.
+
+```bash
+sprag team create --email you@example.com --name "Acme"
+# 메일로 코드가 오면 이어서 실행합니다
+sprag team create --email you@example.com --name "Acme" --code 123456
+```
+
+첫 단계는 코드만 보냅니다. 두 번째 단계에서 코드를 확인하고 팀을 만든 뒤 초대 토큰, 멤버용 명령(`npm i -g sprag-cli@latest && sprag team join <토큰>`), 조직용 환경 변수(`export SPRAG_TEAM_TOKEN=<토큰>`), 대시보드 주소를 출력합니다. 같은 이메일로 https://sprag.io/team/ 에 로그인하면 팀을 관리할 수 있습니다.
+
+기본적으로 이 PC가 첫 멤버로 참여하고 동기화를 한 번 실행합니다. 참여하지 않으려면 `--no-join` 을 붙입니다. 이미 팀에 참여한 PC에서는 먼저 `sprag team leave` 를 실행하거나 `--no-join` 을 붙여야 합니다.
+
+## 개인으로 참여하기
+
+팀 소유자에게 초대 토큰을 받은 뒤 실행합니다.
+
+```bash
+sprag team join <토큰> --name "미나"
+```
+
+Sprag 이 올라갈 항목 목록을 보여 주고 확인을 묻습니다. `--name` 은 표시 이름이며 기본값은 OS 사용자 이름입니다. 터미널이 없는 셸에서는 `--yes` 를 붙여 확인을 대신합니다. 토큰을 생략하면 `SPRAG_TEAM_TOKEN` 을 읽습니다.
+
+결과는 `sprag team status` 로 확인합니다.
+
+## 조직 단위로 등록하기
+
+구성원이 각자 명령을 실행하지 않아도 모든 컴퓨터를 등록하려면 환경에 `SPRAG_TEAM_TOKEN=<토큰>` 을 지정합니다. 흔한 위치는 두 곳입니다.
+
+- 셸 프로필: `export SPRAG_TEAM_TOKEN=<토큰>`
+- Claude Code 관리 설정: `{"env":{"SPRAG_TEAM_TOKEN":"…"}}`
+
+컴퓨터는 다음 세션이 시작될 때 참여합니다. 그다음 첫 세션에는 팀 이름과 두 명령을 알리는 한 줄 안내가 나옵니다. `sprag team status --show-payload` 는 보내는 내용을 보여 주고, `sprag team leave` 는 전송을 멈춥니다.
+
+`leave` 는 환경 변수보다 우선합니다. 팀에서 나온 컴퓨터는 변수가 남아 있어도 저절로 다시 참여하지 않습니다. 소유자가 새 토큰을 발급하고 구성원이 `sprag team join` 을 다시 실행해야 다시 참여합니다.
+
+## 팀 룰
+
+팀 소유자는 대시보드에서 룰을 승인합니다. 구성원도 룰을 제안할 수 있습니다.
+
+```bash
+sprag team propose "커밋 전에 lint 실행" --scope ratchet
+```
+
+`--scope` 는 `ratchet`(기본값) 또는 `model` 입니다. 제안은 소유자가 승인할 때까지 대기 상태로 남습니다.
+
+승인된 룰은 다음 동기화 때 내려옵니다. Sprag 은 이를 `~/.claude/ratchet-team.md`(Codex 는 `<CODEX_HOME>/ratchet-team.md`)에 쓰고, 그 파일이 있는 동안 `~/.claude/CLAUDE.md` 의 전역 harness 블록에서 import 합니다. Sprag 이 세션을 시작할 때 파일을 통째로 다시 쓰므로 직접 고치지 마십시오. `sprag team rules` 는 받아 둔 룰을 보여 줍니다. `sprag team leave` 는 멤버 키, 캐시, import 를 지웁니다.
+
+## 상태 확인, 전송 내용 확인, 나가기
+
+| 명령 | 설명 |
+|---|---|
+| `sprag team join [토큰] [--name <이름>] [--yes]` | 팀에 참여 |
+| `sprag team status [--show-payload]` | 팀, 플랜, 프롬프트 수집 설정, 표시 이름, 마지막 동기화를 보여 줍니다. `--show-payload` 를 붙이면 올라갈 하루 단위 행도 그대로 출력합니다 |
+| `sprag team sync [--force]` | 지금 업로드하고 룰을 받습니다. `--force` 는 6시간 간격을 무시합니다 |
+| `sprag team rules` | 받아 둔 팀 룰 보기 |
+| `sprag team propose "<내용>" [--scope ratchet\|model]` | 팀에 룰 제안 |
+| `sprag team leave` | 팀에서 나가고 업로드 중단 |
+
+## 대시보드
+
+https://sprag.io/team/ 에서 소유자가 이메일 코드로 로그인하고, 팀을 만들고, 초대 토큰을 받습니다. 여기서 최근 30일 동안의 구성원별 지출과 절감액을 보고, 룰을 승인하거나 삭제하고, 구성원을 내보낼 수 있습니다.
+
+## 플랜
+
+Free, Team(좌석당 월 $5), 비즈니스(좌석당 월 $10, 프롬프트 수집 포함)가 있습니다. 자세한 내용은 https://sprag.io/pricing/ 에 있습니다.
+
+## 개인정보 관련 참고
+
+- 소유자는 구성원별 하루 합계를 봅니다. 세션이나 프롬프트는 보지 못합니다.
+- 구성원은 `sprag team status --show-payload` 로 같은 내용을 직접 볼 수 있습니다.
+- 프롬프트 수집은 비즈니스 정책이며, 소유자가 대시보드에서 켤 수 있습니다. 구성원은 `sprag team status` 에서 설정 상태를 확인합니다. 현재 CLI 는 프롬프트를 아직 올리지 않습니다. 업로드는 이후 별도 릴리스에서 다룹니다.
+- 룰 내용은 `sprag team propose` 를 통해서만 밖으로 나갑니다.
+
+## 파일과 환경 변수
+
+| 이름 | 용도 |
+|---|---|
+| `<사용자 데이터 디렉터리>/team.json` | 참여 상태와 멤버 키(권한 0600) |
+| `<사용자 데이터 디렉터리>/team-rules.json` | 마지막 동기화 때 받은 룰 |
+| `~/.claude/ratchet-team.md` | Claude Code 용 승인된 팀 룰이며 `~/.claude/CLAUDE.md` 에서 import 합니다 |
+| `<CODEX_HOME>/ratchet-team.md` | Codex 용 같은 룰 |
+| `SPRAG_TEAM_TOKEN` | 초대 토큰이며, 다음 세션 시작 때 컴퓨터를 등록합니다 |
+| `CTS_NO_TEAM_SYNC=1` | 팀 관련 네트워크 통신을 모두 끕니다 |

package/docs/TEAM.md

@@ -0,0 +1,119 @@
+# Team layer
+
+[← README](../README.md) · [한국어](./TEAM.ko.md)
+
+Sprag is local-only by default. The team layer is an opt-in add-on that lets a group see each member's daily spend and savings in one dashboard, and share the ratchet rules the team owner approves. Nothing is sent until you run `sprag team join <token>` or your environment sets `SPRAG_TEAM_TOKEN`. `CTS_NO_TEAM_SYNC=1` turns off all team network traffic, whatever else is configured.
+
+## What is sent and what is not
+
+After you join, Sprag uploads one row per local calendar day:
+
+| Field | Meaning |
+|---|---|
+| Spend (USD) | priced from your local session logs |
+| Savings (USD) | from the routing and doc2md ledgers |
+| Delegated runs | how many runs were delegated that day |
+| Model-family share | the share of those runs that went to each model family |
+| Sprag version | the installed version |
+| Agent | `claude` or `codex` |
+| Display name | the name you chose at join; the default is your OS user name |
+
+Not sent: prompts, transcripts, file paths, project names, rule text, API keys. A rule leaves your machine only when you run `sprag team propose` yourself.
+
+The upload runs at most once every 6 hours, from a detached child process that the SessionStart hook spawns. It never runs on the statusline path.
+
+Destination: `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` (Supabase, region ap-northeast-2). The calls are the RPCs `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose` and `team_leave`.
+
+## Create a team from the CLI
+
+You can set up a team without the web dashboard. Signing in uses a 6-digit code emailed to you (valid 15 minutes). Sprag never stores the sign-in session.
+
+In a terminal, run one command and answer the prompts (email, code, team name):
+
+```bash
+sprag team create
+```
+
+From an agent or any shell without a terminal, it takes two steps:
+
+```bash
+sprag team create --email you@example.com --name "Acme"
+# the code arrives by email, then:
+sprag team create --email you@example.com --name "Acme" --code 123456
+```
+
+The first step only sends the code. The second verifies it and creates the team. It then prints the invite token, the member command (`npm i -g sprag-cli@latest && sprag team join <token>`), the organization line (`export SPRAG_TEAM_TOKEN=<token>`) and the dashboard address. Sign in to https://sprag.io/team/ with the same email to manage the team.
+
+By default this machine joins as the first member and runs one sync. Pass `--no-join` to skip that. If this machine is already in a team, run `sprag team leave` first or pass `--no-join`.
+
+## Join as an individual
+
+The team owner gives you an invite token. Then:
+
+```bash
+sprag team join <token> --name "Mina"
+```
+
+Sprag prints the list of what will be uploaded and asks for confirmation. `--name` sets the display name (default: your OS user name). In a shell without a terminal, pass `--yes` to confirm. If you leave the token out, Sprag reads `SPRAG_TEAM_TOKEN`.
+
+Check the result with `sprag team status`.
+
+## Enroll an organization
+
+To enroll every machine without each person running a command, set `SPRAG_TEAM_TOKEN=<token>` in the environment. Two common places:
+
+- a shell profile: `export SPRAG_TEAM_TOKEN=<token>`
+- Claude Code managed settings: `{"env":{"SPRAG_TEAM_TOKEN":"…"}}`
+
+The machine joins at the next session start. The first session after that prints a one-line notice that names the team and the two commands that matter: `sprag team status --show-payload` shows what is sent, and `sprag team leave` stops it.
+
+`leave` wins over the environment. A machine that left does not rejoin on its own, even with the variable still set. It rejoins only after the owner issues a new token and the member runs `sprag team join` again.
+
+## Team rules
+
+The team owner approves rules in the dashboard. Members can also suggest one:
+
+```bash
+sprag team propose "Run lint before every commit" --scope ratchet
+```
+
+`--scope` is `ratchet` (the default) or `model`. A proposal stays pending until the owner approves it.
+
+Approved rules come back with the next sync. Sprag writes them to `~/.claude/ratchet-team.md` (Codex: `<CODEX_HOME>/ratchet-team.md`) and imports that file from the global harness block of `~/.claude/CLAUDE.md` for as long as the file exists. Do not edit the file by hand, because Sprag rewrites it at session start. `sprag team rules` lists the cached rules. `sprag team leave` removes the member key, the cache and the import.
+
+## Status, payload and leaving
+
+| Command | What it does |
+|---|---|
+| `sprag team join [token] [--name <n>] [--yes]` | Join a team |
+| `sprag team status [--show-payload]` | Team, plan, prompt-capture flag, display name, last sync. `--show-payload` also prints the exact daily rows that would be uploaded |
+| `sprag team sync [--force]` | Upload now and pull rules. `--force` ignores the 6-hour interval |
+| `sprag team rules` | Show the cached team rules |
+| `sprag team propose "<text>" [--scope ratchet\|model]` | Propose a rule to the team |
+| `sprag team leave` | Leave the team and stop uploading |
+
+## The dashboard
+
+https://sprag.io/team/ is where the owner signs in with an email code, creates a team and gets the invite token. From there the owner sees per-member spend and savings for the last 30 days, approves or removes rules, and removes members.
+
+## Plans
+
+Free, Team ($5 per seat per month) and Business ($10 per seat per month, with prompt capture). Details are on https://sprag.io/pricing/.
+
+## Privacy notes
+
+- The owner sees per-member daily totals, not sessions or prompts.
+- A member sees the same payload with `sprag team status --show-payload`.
+- Prompt capture is a Business policy that the owner can switch on in the dashboard. Members see its state in `sprag team status`. The current CLI does not upload prompts yet; that is a separate, later release.
+- Rule text leaves your machine only through `sprag team propose`.
+
+## Files and environment variables
+
+| Name | Purpose |
+|---|---|
+| `<user data dir>/team.json` | Membership state and the member key (mode 0600) |
+| `<user data dir>/team-rules.json` | Rules pulled at the last sync |
+| `~/.claude/ratchet-team.md` | Approved team rules for Claude Code, imported from `~/.claude/CLAUDE.md` |
+| `<CODEX_HOME>/ratchet-team.md` | The same rules for Codex |
+| `SPRAG_TEAM_TOKEN` | Invite token; enrolls the machine at the next session start |
+| `CTS_NO_TEAM_SYNC=1` | Disables all team network traffic |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.69.0",
+  "version": "3.70.0",
   "description": "Model-delegation router for Claude Code and Codex: lookups, checks and test runs go to cheaper models, documents go in as compact Markdown, and a live statusline shows spend and savings.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "publish:legacy": "node scripts/publish-legacy.mjs",
     "release:notes": "node scripts/release-notes.mjs",
     "site:docs": "node scripts/build-site-docs.mjs",
+    "site:serve": "node scripts/serve-site.mjs",
     "test": "node --test",
     "test:mods": "claude plugin test mod/sprag-doc2md && claude plugin test mod/sprag-delegation-meter && claude plugin test mod/sprag-statusline",
     "version": "node scripts/sync-site-version.mjs"
@@ -30,6 +31,8 @@
     "README.ko.md",
     "docs/CODEX.md",
     "docs/CODEX.ko.md",
+    "docs/TEAM.md",
+    "docs/TEAM.ko.md",
     "LICENSE",
     "NOTICE"
   ],

package/src/agents.js

@@ -26,10 +26,12 @@ const AGENT_MODEL = {
   'haiku-runner': 'haiku',
   'haiku-translate': 'haiku',
   'sonnet-worker': 'sonnet',
+  'opus-worker': 'opus',
   // A T1 rule names its target by tier alone (`agent: 'sonnet'`). Without these
   // the phrase fell through to the haiku default, and a sonnet rule told the
   // session to delegate to haiku. resolveAgentName maps them to an agent file.
   sonnet: 'sonnet',
+  opus: 'opus',
   haiku: 'haiku',
 };
 
@@ -50,7 +52,7 @@ export function agentExists(name, root = process.cwd()) {
 }
 
 /** Agent a bare tier name stands for when that agent's file exists. */
-const TIER_AGENT = { sonnet: 'sonnet-worker', haiku: 'haiku-explore' };
+const TIER_AGENT = { sonnet: 'sonnet-worker', opus: 'opus-worker', haiku: 'haiku-explore' };
 
 /**
  * The agent a rule target really names on this machine, or null when none is

package/src/codex/delegation.js

@@ -36,7 +36,7 @@ export function validateCodexTarget(model, effort) {
 
 export function validateCodexSharedTarget({ tier, from, model, effort, provider }) {
   validateCodexTarget(model, effort);
-  if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1 or T2.');
+  if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1, T1H or T2.');
   if (!safeId(from) || from === model) throw new Error('--from must name a different parent model.');
   if (!safeId(provider)) throw new Error('A shared model mapping requires a Codex provider ID.');
   return { tier, from, model, ...(effort === undefined ? {} : { effort }), provider };
@@ -78,7 +78,7 @@ function catalogCodexModels(home) {
 }
 
 /**
- * The models Codex resolves T2 and T1 to when the user mapped none, the way
+ * The models Codex resolves T2, T1 and T1H to when the user mapped none, the way
  * Claude Code resolves `haiku` and `sonnet`. Candidates are the models that
  * already ran in this user's Codex sessions plus, for the built-in OpenAI
  * provider only, the models Codex's catalog lists for the account (a gateway
@@ -86,7 +86,8 @@ function catalogCodexModels(home) {
  * qualifies only if it is priced on the parent's provider and costs less than
  * the parent, so the hint never names a model the gateway cannot serve. The
  * cheapest is T2 and the next one up is T1; with a single candidate T1 stays
- * on the main agent. Returns { targets, reason }.
+ * on the main agent. T1H is the most expensive cheaper model, and only when
+ * there are at least three candidates, so that it differs from T1. Returns { targets, reason }.
  */
 export function autoCodexSharedTargets({ dir = userDataDir(), home = codexUserDir(), model, provider, now = Date.now() } = {}) {
   if (!safeId(model) || !safeId(provider)) return { targets: [], reason: 'unknown parent model or provider' };
@@ -104,7 +105,9 @@ export function autoCodexSharedTargets({ dir = userDataDir(), home = codexUserDi
       ? `${model} is already the cheapest available model on ${provider}`
       : `no cheaper priced model has run in your Codex sessions on ${provider}` };
   }
-  const targets = cheaper.slice(0, 2).map((x, i) => ({ tier: i === 0 ? 'T2' : 'T1', from: model, model: x.model, provider, auto: true }));
+  const picks = cheaper.slice(0, 2).map((x, i) => ({ tier: i === 0 ? 'T2' : 'T1', x }));
+  if (cheaper.length >= 3) picks.push({ tier: 'T1H', x: cheaper.at(-1) });
+  const targets = picks.map(({ tier, x }) => ({ tier, from: model, model: x.model, provider, auto: true }));
   return { targets, reason: null };
 }
 
@@ -240,7 +243,7 @@ export function codexDelegateMinContext(cfg) {
 // Codex tells the model to set spawn_agent's model only on the user's request,
 // so the shared hint says where this request came from.
 const SHARED_APPROVAL = 'The user approved this policy and its model mapping, so setting model here follows the user\'s request.';
-const SHARED_TIER_GUIDANCE = 'Choose T2 only for a simple bounded lookup or command. Use T1 for multi-step tool chains or work spanning multiple files. If the required tier is not mapped, keep the task on the main agent. Do not delegate design judgement, diagnosis, or irreversible actions.';
+const SHARED_TIER_GUIDANCE = 'Choose T2 only for a simple bounded lookup or command. Use T1 for multi-step tool chains or work spanning multiple files. Use T1H only for large-scope work that T1 would likely get wrong. If the required tier is not mapped, keep the task on the main agent. Do not delegate design judgement, diagnosis, or irreversible actions.';
 const WAIT_TEXT = 'Wait for it to finish (call wait_agent with timeout_ms of at least 120000, and again if it times out) and do not do the delegated task yourself while it runs; then verify its result and report unfinished work. Do not spawn another CLI process. '
   + 'If sub-agent tools or the target model are unavailable, keep the task on the main agent and state that delegation was unavailable.';
 

package/src/codex/hooks.js

@@ -183,10 +183,21 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
       try { (await import('../preset-ratchet.js')).preparePresetRatchet({ agent: 'codex' }); } catch (e) { debug('codex:preset', e); }
     }
     const { presetRatchetPath } = await import('../preset-ratchet.js');
+    let teamRatchetPath = () => '';
+    let teamNotice = null;
+    try {
+      const tr = await import('../team-ratchet.js');
+      teamRatchetPath = tr.teamRatchetPath;
+      if (event === 'session-start') {
+        tr.syncTeamRatchet({ agent: 'codex' });
+        tr.spawnTeamSyncIfDue();
+        teamNotice = tr.autoJoinNoticeBlock(undefined, 'en');
+      }
+    } catch (e) { debug('codex:team-ratchet', e); }
     // Lower priority survives the budget first. Rules and style move to a file
     // when they do not fit; offers and notices are simply left out.
     for (const [scope, ratchet] of [['global', codexHarnessPaths(root, 'global').ratchet],
-      ['preset', presetRatchetPath({ agent: 'codex' })], ['project', codexHarnessPaths(root, 'project').ratchet]]) {
+      ['preset', presetRatchetPath({ agent: 'codex' })], ['team', teamRatchetPath({ agent: 'codex' })], ['project', codexHarnessPaths(root, 'project').ratchet]]) {
       try {
         if (statSync(ratchet).size > 32 * 1024) {
           parts.push({ priority: 1, text: `Read the ${scope} Sprag ratchet rules at ${JSON.stringify(ratchet)} before working; they exceed the automatic injection limit.` });
@@ -194,10 +205,11 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
           const text = readFileSync(ratchet, 'utf8').trim();
           // An empty preset file is only its header; injecting it would spend
           // tokens every session on no rules.
-          if (text && (scope !== 'preset' || /^- /m.test(text))) parts.push({ priority: 1, spill: true, text: `[Sprag Codex ratchet: ${scope}]\n${text}` });
+          if (text && ((scope !== 'preset' && scope !== 'team') || /^- /m.test(text))) parts.push({ priority: 1, spill: true, text: `[Sprag Codex ratchet: ${scope}]\n${text}` });
         }
       } catch (e) { if (e?.code !== 'ENOENT') debug('codex:ratchet', e); }
     }
+    if (teamNotice) parts.push({ priority: 5, text: teamNotice });
     if (event === 'subagent-start') parts.push({ priority: 0, text:
       '[Sprag Codex delegation]\nStay within the assigned task and any caller-provided budget. Return findings with file references and actual verification results; state unfinished work. Use only available Codex tools and configured roles. Do not infer a model tier or invent a tool-call budget.' });
     // Codex reads the Korean guide from the global AGENTS.md, so the hook adds it

package/src/codex/route-scan.js

@@ -92,7 +92,9 @@ function pickTarget(group, { prices, known, home }) {
     .sort((a, b) => a.usd - b.usd);
   const eligible = cheaper.filter((x) => known.has(`${group.provider}|${x.model}`));
   // Simple work goes to the cheapest model; moderate work steps down one notch.
-  const pick = group.tiers.T2 >= group.tiers.T1 ? eligible[0] : eligible.at(-1);
+  // The heaviest band goes to the most expensive cheaper model (the T1H target).
+  const { T2, T1, T1H } = group.tiers;
+  const pick = T2 >= T1 && T2 >= T1H ? eligible[0] : eligible.at(-1);
   return {
     suggestedModel: pick?.model ?? null,
     alternatives: pick ? [] : cheaper.slice(0, 3).map((x) => x.model),
@@ -135,10 +137,10 @@ export async function runCodexRouteScan({ days = 14, now = Date.now(), home, dir
     const runtime = codexPromptCategory(ep.text);
     if (!runtime || !categorize(ep.text, ep.tools)) continue;
     const tier = tierOf(ep, runtime, thresholds);
-    if (tier !== 'T1' && tier !== 'T2') continue;
+    if (tier !== 'T1' && tier !== 'T2' && tier !== 'T1H') continue;
     const key = `${runtime.id}|${ep.provider}|${ep.model}|${ep.projectRoot}`;
     const g = groups.get(key) || { signature: key, category: runtime.id, label: runtime.label, labelEn: runtime.labelEn,
-      from: ep.model, provider: ep.provider, projectRoot: ep.projectRoot, count: 0, tiers: { T1: 0, T2: 0 }, example: ep.text,
+      from: ep.model, provider: ep.provider, projectRoot: ep.projectRoot, count: 0, tiers: { T1: 0, T2: 0, T1H: 0 }, example: ep.text,
       tokens: { input: 0, cached: 0, cacheWrite: 0, output: 0 }, lastSeen: 0 };
     g.count++;
     g.tiers[tier]++;
@@ -154,7 +156,7 @@ export async function runCodexRouteScan({ days = 14, now = Date.now(), home, dir
         (!r.provider || r.provider === g.provider) &&
         (r.scope === 'global' || r.targetRoot === g.projectRoot))) return true;
     const shared = sharedCodexModelRules({ cfg, dir, root: g.projectRoot, model: g.from, provider: g.provider });
-    return ['T1', 'T2'].every((tier) => !g.tiers[tier] || shared.some((r) => r.category === g.category && r.tier === tier));
+    return ['T1', 'T2', 'T1H'].every((tier) => !g.tiers[tier] || shared.some((r) => r.category === g.category && r.tier === tier));
   };
   const known = new Set([...observed, ...rules.filter((r) => r.provider).map((r) => `${r.provider}|${r.model}`)]);
   const target = cfg?.codex?.delegateTarget?.model;

package/src/commands/codex-delegate.js

@@ -43,7 +43,7 @@ function printShared(cfg, { details = false } = {}) {
   if (missing.length) {
     console.log(`Unmapped tiers for ${parent || 'any parent model'} on ${provider || 'unknown provider'}: ${missing.join(', ')}`
       + `${autoOn && auto.reason ? ` (auto: ${auto.reason})` : ''}. `
-      + `Set: sprag delegate shared map <T1|T2> --from ${parent || '<parent-model>'} --model <target-model> --agent codex`);
+      + `Set: sprag delegate shared map <T1|T1H|T2> --from ${parent || '<parent-model>'} --model <target-model> --agent codex`);
   }
   console.log(`Automatic tier models: ${autoOn ? 'on' : 'off'} (turn ${autoOn ? 'off' : 'on'}: sprag delegate shared auto ${autoOn ? 'off' : 'on'} --agent codex)`);
   if (!parent && targets.length) console.log('Codex config names no default model; each mapping routes only sessions on its --from model.');
@@ -74,7 +74,7 @@ export function run({ args, getArg, hasFlag, root }) {
   if (sub === 'shared') {
     const action = args[2] || 'status';
     if (!['status', 'on', 'off', 'map', 'unmap', 'min-context', 'auto'].includes(action)) {
-      throw new Error('Usage: delegate shared status|on|off|map <T1|T2>|unmap <T1|T2>|min-context <tokens|default>|auto on|off --agent codex');
+      throw new Error('Usage: delegate shared status|on|off|map <T1|T1H|T2>|unmap <T1|T1H|T2>|min-context <tokens|default>|auto on|off --agent codex');
     }
     if (hasFlag('--global') || hasFlag('--project')) throw new Error('Shared policies retain their approved scope; mappings do not change it.');
     const provided = (flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
@@ -86,7 +86,7 @@ export function run({ args, getArg, hasFlag, root }) {
       const tier = args[3];
       const from = getArg('--from');
       const provider = getArg('--provider') ?? codexProviderName();
-      if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1 or T2.');
+      if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1, T1H or T2.');
       const same = (t) => t.tier === tier && t.from === from && t.provider === provider;
       if (action === 'map') {
         const target = validateCodexSharedTarget({ tier, from, provider, model: getArg('--model'), effort: getArg('--effort') });

package/src/commands/codex.js

@@ -30,9 +30,9 @@ Usage: sprag <command> --agent codex [options]
   delegate implementation       After design: resolve T1 with --from, --provider, --session
   delegate rules                Codex rules and shared delegation policies
   delegate shared on|off|status  Reuse approved policies; keep original scopes
-  delegate shared map T1|T2     Map a tier: --from <parent> --model <target>
+  delegate shared map T1|T1H|T2 Map a tier: --from <parent> --model <target>
                                 Optional --provider <id> and --effort <level>
-  delegate shared unmap T1|T2   Remove a mapping: --from <parent> [--provider <id>]
+  delegate shared unmap T1|T1H|T2 Remove a mapping: --from <parent> [--provider <id>]
   delegate shared min-context N Parent input tokens before shared guidance; default resets
   delegate shared auto on|off   Resolve unmapped tiers from priced models already run in Codex
   route-scan [--refresh]         Discover recurring simple turns in local logs
@@ -202,7 +202,7 @@ export async function run({ args, version }) {
     for (const c of open) {
       const target = c.suggestedModel ? `-> ${c.suggestedModel}${Number.isFinite(c.estSavedUsd) ? ` (~${signedUsd(c.estSavedUsd, 4)} over ${c.count} turns)` : ''}`
         : `-> choose --model${c.alternatives.length ? ` (priced cheaper: ${c.alternatives.join(', ')})` : ''}`;
-      console.log(`R${c.id} ${c.category} x${c.count} [T2 ${c.tiers.T2} / T1 ${c.tiers.T1}] ${c.provider || 'unknown provider'} / ${c.from} ${target}`);
+      console.log(`R${c.id} ${c.category} x${c.count} [T2 ${c.tiers.T2} / T1 ${c.tiers.T1} / T1H ${c.tiers.T1H ?? 0}] ${c.provider || 'unknown provider'} / ${c.from} ${target}`);
       console.log(`   ${c.projectRoot}`);
       console.log(`   e.g. ${JSON.stringify(c.example)}`);
     }

package/src/commands/harness.js

@@ -255,7 +255,7 @@ export async function run({ args, hasFlag }) {
           example: routeCandidate.example,
           count: routeCandidate.count,
           // Calibrated budget snapshot — ratchet-model.md restates it when it
-          // merges a category's T2 and T1 rules into one conditional rule.
+          // merges a category's T2, T1 and T1H rules into one conditional rule.
           budget: routeCandidate.budget || null,
           promotedAt: new Date().toISOString().slice(0, 10),
           lastSeen: new Date().toISOString().slice(0, 10),

package/src/commands/route-scan.js

@@ -303,6 +303,17 @@ export async function run({ args, hasFlag, numArg }) {
       // bundled rule reaches ratchet-preset.md here, without a reinstall. It
       // also moves presets older versions appended to ratchet.md.
       try { (await import('../preset-ratchet.js')).preparePresetRatchet(); } catch (e) { debug('route-scan:sync-preset', e); }
+      // Team layer (opt-in): re-render the team ratchet file from the cached rules,
+      // keep the CLAUDE.md import in step with the file, and kick the detached sync
+      // when it is due. Nothing here touches the network.
+      let teamBlock = null;
+      try {
+        const tr = await import('../team-ratchet.js');
+        tr.syncTeamRatchet({ lang });
+        tr.ensureTeamImport();
+        tr.spawnTeamSyncIfDue();
+        teamBlock = tr.autoJoinNoticeBlock(undefined, lang);
+      } catch (e) { debug('route-scan:team', e); }
       // Cowork cannot follow the ~/.claude imports, so it gets a pasted copy.
       try { (await import('../cowork-sync.js')).syncCoworkRatchets({ discover: true }); } catch (e) { debug('route-scan:cowork-sync', e); }
       // Registered rules whose delegated-category error rate crossed the
@@ -375,6 +386,7 @@ export async function run({ args, hasFlag, numArg }) {
       } catch (e) { debug('route-scan:update-check', e); /* the offer is optional */ }
 
       if (open.length === 0 && reviewRules.length === 0) {
+        if (teamBlock) console.log(teamBlock);
         if (updateBlock) console.log(updateBlock);
         if (seedBlock) console.log(seedBlock);
         if (doc2mdBlock) console.log(doc2mdBlock);
@@ -382,6 +394,7 @@ export async function run({ args, hasFlag, numArg }) {
         if (cohesionBlock) console.log(cohesionBlock);
         return; // nothing else to inject
       }
+      if (teamBlock) console.log(teamBlock);
       if (updateBlock) console.log(updateBlock);
       if (seedBlock) console.log(seedBlock);
       if (doc2mdBlock) console.log(doc2mdBlock);
@@ -392,10 +405,10 @@ export async function run({ args, hasFlag, numArg }) {
       if (open.length > 0) {
         if (lang === 'ko') {
           lines.push(`[sprag route-scan] 최근 ${cache.days}일 세션에서 비싼 모델(opus/fable)이 반복 처리해 온, 더 싼 모델로 넘겨도 되는 작업이 감지되었습니다.`);
-          lines.push('(R<N>은 후보 번호, T2/T1은 난이도 등급입니다 — 사용자에게 전달할 때는 코드가 아니라 아래 풀어쓴 설명으로 브리핑하세요)');
+          lines.push('(R<N>은 후보 번호, T2/T1/T1H는 난이도 등급입니다 — 사용자에게 전달할 때는 코드가 아니라 아래 풀어쓴 설명으로 브리핑하세요)');
         } else {
           lines.push(`[sprag route-scan] Over the last ${cache.days} days, expensive models (opus/fable) repeatedly handled work that a cheaper model could take.`);
-          lines.push('(R<N> is the candidate id, T2/T1 the difficulty tier — brief the user with the spelled-out wording below, not the codes.)');
+          lines.push('(R<N> is the candidate id, T2/T1/T1H the difficulty tier — brief the user with the spelled-out wording below, not the codes.)');
         }
         for (const c of open) {
           const tier = c.tier || 'T2';
@@ -490,7 +503,7 @@ export async function run({ args, hasFlag, numArg }) {
       (await import('../first-run-note.js')).printOnce('route-scan', lang);
       return;
     }
-    console.log(lang === 'ko' ? '\n위임 후보 (R<N>=후보 번호, T2/T1=난이도 등급):' : '\nDelegation candidates (R<N> = candidate id, T2/T1 = difficulty tier):');
+    console.log(lang === 'ko' ? '\n위임 후보 (R<N>=후보 번호, T2/T1/T1H=난이도 등급):' : '\nDelegation candidates (R<N> = candidate id, T2/T1/T1H = difficulty tier):');
     for (const c of open) {
       const tier = c.tier || 'T2';
       if (lang === 'ko') {