sprag-cli 3.70.0 → 3.72.0

package/presets/agents.json

@@ -0,0 +1,118 @@
+{
+  "note": [
+    "Delegation-only subagents written to ~/.claude/agents by syncDelegationAgents().",
+    "Same shape as the \"agents\" array of a published preset bundle, so the bundled copy",
+    "and a remote bundle render through one path. A remote bundle replaces this list",
+    "when its signature verifies; otherwise this file is used.",
+    "Models are aliases on purpose (a gateway resolves them through ANTHROPIC_DEFAULT_*_MODEL),",
+    "except opus-worker, which names the full id: a bare alias resolves to an older model.",
+    "Effort follows how the work is verified: low for lookups and command runs, medium for",
+    "implementation against tests, high for the larger opus share.",
+    "The files are rendered in English (description.en, body.en): they are model-facing",
+    "prompts, and the Korean copy is what the /ops console shows next to it."
+  ],
+  "agents": [
+    {
+      "name": "haiku-explore",
+      "model": "haiku",
+      "effort": "low",
+      "tools": [
+        "Read",
+        "Grep",
+        "Glob",
+        "Bash"
+      ],
+      "description": {
+        "ko": "위임 작업용 저비용 읽기 전용 탐색, 조회, 상태 확인, 요약 에이전트입니다. MCP 도구는 없습니다.",
+        "en": "Cheap read-only exploration, lookup, status checks and summaries for delegated tasks. It has no MCP tools."
+      },
+      "body": {
+        "ko": "맡은 역할: 읽기 전용 탐색, 조회, 상태 확인, 붙여넣은 로그나 텍스트를 두고 묻는 질문에 답합니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.",
+        "en": "Your role: read-only exploration, lookups, status checks, and questions about pasted logs or text.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it."
+      }
+    },
+    {
+      "name": "haiku-runner",
+      "model": "haiku",
+      "effort": "low",
+      "tools": [
+        "Bash",
+        "Read",
+        "Grep",
+        "Glob"
+      ],
+      "description": {
+        "ko": "위임 작업의 빌드·테스트·git 명령을 실행하는 저비용 에이전트입니다. MCP 도구는 없습니다.",
+        "en": "Cheap runner for build, test and git commands in delegated tasks. It has no MCP tools."
+      },
+      "body": {
+        "ko": "맡은 역할: 전달받은 빌드·테스트·git 명령을 실행하고 결과를 보고합니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
+        "en": "Your role: run the build, test, or git commands you are given and report the result.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
+      }
+    },
+    {
+      "name": "haiku-translate",
+      "model": "haiku",
+      "effort": "low",
+      "tools": [
+        "Read",
+        "Grep",
+        "Glob",
+        "Edit",
+        "Write"
+      ],
+      "description": {
+        "ko": "위임 작업용 저비용 일괄 번역·정형 텍스트 변환 에이전트입니다. MCP 도구는 없습니다.",
+        "en": "Cheap batch translation and structured text conversion for delegated tasks. It has no MCP tools."
+      },
+      "body": {
+        "ko": "맡은 역할: 전달받은 파일이나 텍스트의 일괄 번역과 정형 텍스트 변환입니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.",
+        "en": "Your role: batch translation and mechanical text conversion of the files or text you are given.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it."
+      }
+    },
+    {
+      "name": "sonnet-worker",
+      "model": "sonnet",
+      "effort": "medium",
+      "tools": [
+        "Read",
+        "Grep",
+        "Glob",
+        "Bash",
+        "Edit",
+        "Write",
+        "NotebookEdit"
+      ],
+      "description": {
+        "ko": "여러 단계 작업과 설계가 확정된 구현을 맡는 중간 티어 워커입니다. MCP 도구는 없습니다.",
+        "en": "Mid-tier worker for multi-step tasks and implementation handed over with a fixed design. It has no MCP tools."
+      },
+      "body": {
+        "ko": "맡은 역할: 여러 단계로 이어지는 작업과, 호출자가 설계를 확정한 구현을 맡습니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
+        "en": "Your role: multi-step work and the implementation half of a design the caller already fixed.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
+      }
+    },
+    {
+      "name": "opus-worker",
+      "model": "claude-opus-5-5",
+      "effort": "high",
+      "tools": [
+        "Read",
+        "Grep",
+        "Glob",
+        "Bash",
+        "Edit",
+        "Write",
+        "NotebookEdit"
+      ],
+      "description": {
+        "ko": "Fable 세션용 고성능 워커로, 설계가 확정된 대규모 구현·디버깅·리팩터링을 맡습니다. MCP 도구는 없습니다.",
+        "en": "Heavy worker for Fable sessions: large implementation, debugging and refactoring handed over with a fixed design. It has no MCP tools."
+      },
+      "body": {
+        "ko": "맡은 역할: 호출자가 설계를 확정한 대규모 구현과 디버깅입니다. 설계 판단과 되돌릴 수 없는 작업은 호출자에게 넘기십시오.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
+        "en": "Your role: large implementation and debugging work whose design the caller already fixed. Hand design judgement and irreversible actions back to the caller.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
+      }
+    }
+  ]
+}

package/presets/doc2md/convert.py

@@ -34,7 +34,7 @@ import zipfile
 
 MAX_UNCOMPRESSED = 500 * 1024 * 1024
 MAX_RATIO = 200
-ROW_CAP = int(os.environ.get("CTS_DOC2MD_ROW_CAP", "50000"))
+ROW_CAP = int(os.environ.get("SPRAG_DOC2MD_ROW_CAP", os.environ.get("CTS_DOC2MD_ROW_CAP", "50000")))
 ZIP_EXTS = {".pptx", ".xlsx", ".docx"}
 
 

package/presets/ratchet-rules.json

@@ -6,31 +6,39 @@
     "each answer. Both read this file, so there is one source for the wording.",
     "Each rule carries both languages because the text is injected into the model's",
     "context, where a Korean-only rule would steer an English session into Korean.",
-    "Ids are derived from the `ko` text (the canonical one), so a rule keeps its",
-    "identity — and a user's 'no' — when the English wording is revised."
+    "Each rule carries a stable `id`. It was derived once from the `ko` text",
+    "(fix-<sha1(ko)[0:6]>) and is kept when the wording changes, so a rule keeps its",
+    "identity, and a user's 'no', across rewording. This file is also the fallback for",
+    "the centrally published preset bundle; `npm run presets:pull` refreshes it."
   ],
   "rules": [
     {
+      "id": "fix-bd7836",
       "ko": "웹 fetch/search에서 robots·UA 차단('unable to fetch' 등)이 발생하면 → curl에 브라우저 UA(Mozilla/5.0 ... Chrome/...) 헤더를 붙여 재시도. reddit 등은 .json 엔드포인트 + UA 조합으로 접근 가능",
       "en": "When a web fetch/search is blocked by robots or user-agent checks ('unable to fetch' and similar) → retry with curl carrying a browser UA header (Mozilla/5.0 ... Chrome/...). Sites like reddit also answer on their .json endpoints with that UA"
     },
     {
+      "id": "fix-4168c2",
       "ko": "ratchet 룰 promote 호출 직전 사용자에게 scope(global/project)를 먼저 묻는다 — Bash 환경은 non-TTY라 CLI readline 프롬프트가 안 뜨므로, 호출자(LLM)가 대신 묻고 --global/--project 플래그를 명시해 실행",
       "en": "Ask the user for the scope (global or project) before calling ratchet promote — the Bash environment is non-TTY, so the CLI's readline prompt never appears; the caller (the model) has to ask and pass --global/--project explicitly"
     },
     {
+      "id": "fix-ce98b4",
       "ko": "자동화 도구가 grep·정규식으로 찾는 마커 텍스트(헤더·앵커·키워드 라인)는 리팩터링·압축·수정 금지 — 정확 매칭 검출은 한 글자만 바뀌어도 깨짐",
       "en": "Never refactor, compress or reword marker text that an automated tool finds by grep or regex (headings, anchors, keyword lines) — exact-match detection breaks on a single changed character"
     },
     {
+      "id": "fix-b1da7a",
       "ko": "자동화 설계에서 vision/screenshot 루프가 보이면 → 호출 가능한 함수·API·MCP tool부터 찾는다. 통제 가능한 내부 도구는 무조건 API, 통제 불가 외부 SaaS만 vision 차선책. 인터페이스를 바꾼 뒤에 모델을 내린다 — 거꾸로 가면 토큰 폭발",
       "en": "When an automation design calls for a vision/screenshot loop → look for a callable function, API or MCP tool first. Anything you control gets an API; vision is the fallback only for external SaaS you cannot change. Fix the interface before lowering the model — doing it the other way round explodes the token cost"
     },
     {
+      "id": "fix-1dee5f",
       "ko": "입력 데이터(ground-truth) 변경 시 그에 의존하는 모든 파생 자산을 끝까지 재생성한다 — 중간 단계를 생략하면 stale 산출물이 새 입력 위에 얹혀 결과가 깨짐",
       "en": "When the ground-truth input changes, regenerate every derived asset all the way through — skipping an intermediate step leaves a stale artifact sitting on top of the new input and the result breaks"
     },
     {
+      "id": "fix-f558f9",
       "ko": "탐색·조회·상태 확인·명령 실행 같은 단순 요청은 `model: haiku` 서브에이전트로 위임해 상위 모델 토큰을 아낀다 (읽기 전용 preset 에이전트가 이미 있으면 그걸 쓰고, 없으면 티어만 내려서 위임)",
       "en": "Delegate simple requests — lookup, status checks, running commands — to a `model: haiku` subagent to keep the expensive model's tokens for real work (use an existing read-only preset agent when there is one; otherwise delegate with the tier lowered)",
       "agents": [
@@ -38,15 +46,22 @@
       ]
     },
     {
+      "id": "fix-aa18bc",
       "ko": "지침이나 룰이 지켜지지 않아 같은 품질 문제가 재발하면 문구를 다시 쓰지 말 것 → 그 조항이 기계로 판정 가능한지부터 따지고(문자열 비교나 정규식으로 결정되면 판정 가능), 가능하면 쓰기 시점 훅이나 테스트 같은 차단 지점을 추가한다. 판단이 필요한 잔여 부분만 지침에 남기고 그 경계를 지침에 적는다. 실제 코퍼스에 돌려 오탐 건수를 센 뒤 좁히고, 회귀 테스트를 같은 커밋에 넣는다",
       "en": "When a guideline keeps being violated and the same quality defect recurs, do NOT reword the instruction → first ask whether the clause is machine-decidable (a string comparison or regex settles it), and if so add an enforcement point such as a write-time hook or a test. Leave only the judgement remainder in the prose and state that boundary there. Measure the false-positive count on a real corpus, narrow until it is acceptable, and land a regression test in the same commit"
     },
     {
+      "id": "fix-777a15",
       "ko": "여러 파일에 걸친 구현을 맡으면 → 설계와 스펙 확정은 메인 모델이 하고 코드 작성은 서브에이전트에 위임한다(Claude는 `model: sonnet`, Codex는 명시적 매핑을 우선해 해석한 T1을 쓰며 haiku나 T2에는 구현을 맡기지 않는다). 위임 프롬프트에는 설계, 수정할 파일, 제약, 완료 기준, 테스트 명령, 예산, 권장 모델과 그 이유를 적어 다른 문맥 없이 실행할 수 있게 한다. 이미 읽은 파일의 약 50줄 이하 변경이나 의존 단계가 하나뿐인 짧은 구현, 그리고 위임 도구나 하위 모델을 쓸 수 없는 경우는 메인 모델이 직접 처리한다. 위임한 구현은 끝날 때까지 기다리고 같은 구현을 중복 실행하지 않으며, 돌아온 diff와 테스트 결과를 메인 모델이 직접 검증한 뒤에 완료로 보고한다",
       "en": "When an implementation spans several files → the main model settles the design and specification, then delegates the code writing to a subagent (Claude: `model: sonnet`; Codex: its resolved T1, explicit mapping first; never haiku or T2 for implementation). Write the delegation prompt so it runs without other context: design, files to change, constraints, completion criteria, test commands, budget, and the recommended model with a one-line reason. Keep changes of roughly 50 lines or less in files already read, a single short dependency chain, or cases where the subagent tools or the lower model are unavailable on the main model. Wait for the delegated work instead of duplicating it, and verify the returned diff and the actual test results before reporting completion",
       "agents": [
         "claude"
       ]
+    },
+    {
+      "id": "fix-bec8e9",
+      "ko": "전체 테스트·빌드·렌더처럼 프로세스를 여럿 띄우는 명령을 직접 돌리거나 서브에이전트에 맡길 때 → 프로세스 상한을 걸고 실행한다. macOS 와 Linux 는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싼다. 상한에 걸리면 커널이 `spawn ... EAGAIN` 으로 거절하므로 머신이 멈추는 대신 범인 명령줄이 남는다(2026-10-20 테스트 파일이 자신을 복제해 node 4,055개, 메모리 고갈로 세 번 멈춤). `EAGAIN` 은 테스트 실패가 아니라 폭주 신호이므로 재실행하지 말고 `ps` 스냅샷으로 어떤 명령이 불어났는지부터 본다. 백그라운드 자식을 띄우는 코드는 `process.argv[1]` 대신 모듈 위치에서 구한 진입점 경로와 재진입 마커를 쓴다",
+      "en": "When you run, or hand a subagent, a command that starts many processes (a full test suite, a build, a render) → run it under a process cap. On macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`. At the cap the kernel refuses with `spawn ... EAGAIN`, so the culprit's command line survives instead of the machine stalling (2026-10-20: a test file relaunched itself, 4,055 node processes, three memory-exhaustion stalls). `EAGAIN` is a runaway signal, not a test failure: do not rerun; take a `ps` snapshot and see which command multiplied. Code that starts a background child uses an entry path resolved from the module's location plus a re-entry marker, never `process.argv[1]`"
     }
   ]
 }

package/src/cli-entry.js

@@ -0,0 +1,40 @@
+/**
+ * The script a detached child of this CLI must run.
+ *
+ * The preset sync and the two team syncs start a detached child to do their
+ * network work, and they used to pass `process.argv[1]` as its script. Inside
+ * the CLI that is bin/cli.js. Inside anything else that imports these modules
+ * it is that caller's script: under `node --test` a test file relaunched
+ * itself, detached, on every session-start case, and each copy did the same.
+ * 4,055 processes in 59 seconds on 2026-10-20, and three memory-exhaustion
+ * stalls in two days. So the entry is fixed here from this module's own
+ * location, and a spawned child carries a marker that refuses to spawn again.
+ */
+import * as childProcess from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { envVar } from './env.js';
+
+export const CLI_ENTRY = fileURLToPath(new URL('../bin/cli.js', import.meta.url));
+
+/** The marker a detached child carries; read through envVar('DETACHED_CHILD'). */
+export const DETACHED_CHILD_VAR = 'SPRAG_DETACHED_CHILD';
+
+export function isDetachedChild(env = process.env) {
+  return envVar('DETACHED_CHILD', env) === '1';
+}
+
+/** The environment for a detached child: the caller's, plus the marker. */
+export function detachedChildEnv(env = process.env) {
+  return { ...env, [DETACHED_CHILD_VAR]: '1' };
+}
+
+/**
+ * Start `sprag <args>` detached, never awaited, never from a detached child.
+ * Returns true when a child was started. Every background refresh goes
+ * through here so that no caller can name the script itself.
+ */
+export function spawnDetachedCli(args, { env = process.env, spawn = childProcess.spawn, execPath = process.execPath } = {}) {
+  if (isDetachedChild(env)) return false;
+  spawn(execPath, [CLI_ENTRY, ...args], { detached: true, stdio: 'ignore', windowsHide: true, env: detachedChildEnv(env) }).unref();
+  return true;
+}

package/src/codex/hooks.js

@@ -1,5 +1,6 @@
+import { envVar } from '../env.js';
+import { spawnDetachedCli } from '../cli-entry.js';
 import { createRequire } from 'node:module';
-import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { mkdirSync, openSync, readFileSync, readSync, closeSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
@@ -116,9 +117,8 @@ async function routeNotice(root, { spawnRescan = defaultRescan } = {}) {
 }
 
 function defaultRescan() {
-  if (process.env.CTS_NO_ROUTE_SCAN === '1') return;
-  spawn(process.execPath, [process.argv[1], 'route-scan', '--refresh', '--quiet', '--agent', 'codex'],
-    { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+  if (envVar('NO_ROUTE_SCAN') === '1') return;
+  spawnDetachedCli(['route-scan', '--refresh', '--quiet', '--agent', 'codex']);
 }
 
 /**
@@ -130,9 +130,8 @@ function defaultRescan() {
  * of the parent is the earliest point that knows one was spawned.
  */
 function defaultLedgerRefresh() {
-  if (process.env.CTS_NO_ROUTE_SCAN === '1') return;
-  spawn(process.execPath, [process.argv[1], 'route-scan', 'savings', '--refresh', '--quiet', '--agent', 'codex'],
-    { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+  if (envVar('NO_ROUTE_SCAN') === '1') return;
+  spawnDetachedCli(['route-scan', 'savings', '--refresh', '--quiet', '--agent', 'codex']);
 }
 
 export function lintCodexTool(payload, { scope = 'all' } = {}) {
@@ -180,6 +179,7 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
     const parts = [];
     // Keep the preset file current with this version's wording before it is read.
     if (event === 'session-start') {
+      try { (await import('../preset-sync.js')).spawnPresetSyncIfDue(); } catch (e) { debug('codex:preset-sync', e); }
       try { (await import('../preset-ratchet.js')).preparePresetRatchet({ agent: 'codex' }); } catch (e) { debug('codex:preset', e); }
     }
     const { presetRatchetPath } = await import('../preset-ratchet.js');
@@ -219,7 +219,7 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
     try { korean = syncCodexKoreanBlock({ cfg }); } catch (e) { debug('codex:korean-sync', e); }
     if (korean?.action !== 'unchanged') parts.push({ priority: 2, spill: true, text: koreanStyleInjection({ cfg }) });
     parts.push({ priority: 3, spill: true, text: await cohesionInjection({ cfg }) });
-    if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) parts.push({ priority: 4, spill: true, text: codexDocumentNote() });
+    if (envVar('NO_DOC2MD') !== '1' && cfg?.codex?.doc2md !== false) parts.push({ priority: 4, spill: true, text: codexDocumentNote() });
     // Offers ask the user a question; a `codex exec` run has no one to answer it.
     if (event === 'session-start' && payload.source !== 'compact' && !isCodexExecSession(payload.transcript_path)) {
       if (version) parts.push({ priority: 5, text: updateOffer(version, { agent: 'codex', lang: userLanguage() }) });
@@ -231,6 +231,7 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
   }
   if (event === 'prompt') {
     const parts = [];
+    try { (await import('../team-ratchet.js')).spawnTeamSyncOnPrompt(); } catch (e) { debug('codex:team-prompts', e); }
     if (codexDelegateEnabled(cfg)) {
       // Before the hint for this prompt is recorded: a hint from an earlier turn
       // that no child claimed is closed, and children that did run get priced.
@@ -247,14 +248,14 @@ export async function codexHookOutput(event, payload, { cfg = loadConfig(), refr
       }
       catch (e) { debug('codex:brief', e); }
     }
-    if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) {
+    if (envVar('NO_DOC2MD') !== '1' && cfg?.codex?.doc2md !== false) {
       const identity = codexDocumentContext(payload);
       parts.push(doc2md.contextForPrompt(payload, { lang: userLanguage(), agent: 'codex', convert: (source) => convertCodexDocument(source, identity) }));
     }
     return context('UserPromptSubmit', parts.filter(Boolean).join('\n\n'));
   }
   if (event === 'pre-tool') {
-    if (process.env.CTS_NO_DOC2MD !== '1' && cfg?.codex?.doc2md !== false) {
+    if (envVar('NO_DOC2MD') !== '1' && cfg?.codex?.doc2md !== false) {
       const result = codexDocumentTool(payload);
       if (result) return result;
     }

package/src/codex/panel-setup.js

@@ -8,6 +8,7 @@
  * not zsh, or the user already has their own `codex` alias/function.
  */
 
+import { envVar } from '../env.js';
 import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
@@ -21,7 +22,7 @@ export function tmuxAvailable({ exec = execFileSync } = {}) {
 
 export function ensureTmux({ platform = process.platform, env = process.env, exec = execFileSync, exists = existsSync } = {}) {
   // Checked first, before probing anything, so tests and CI never spawn brew.
-  if (env.CTS_NO_TMUX === '1' || (env.CI && env.CI !== 'false')) return { status: 'skipped' };
+  if (envVar('NO_TMUX', env) === '1' || (env.CI && env.CI !== 'false')) return { status: 'skipped' };
   if (tmuxAvailable({ exec })) return { status: 'present' };
   if (platform !== 'darwin') {
     return { status: 'unavailable', detail: 'install tmux with your package manager (e.g. sudo apt install tmux)' };

package/src/codex/panel.js

@@ -1,3 +1,4 @@
+import { envVar } from '../env.js';
 import { resolve, relative, isAbsolute, basename } from 'node:path';
 import { realpathSync, statSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
@@ -151,7 +152,7 @@ export function createPanelReader({ root = process.cwd(), home, sessionId: pinne
       cohesion: cfg?.cohesion?.enabled === true,
       brief: cfg?.codex?.brief !== false,
       delegate: codexDelegateEnabled(cfg),
-      doc2md: cfg?.codex?.doc2md !== false && process.env.CTS_NO_DOC2MD !== '1',
+      doc2md: cfg?.codex?.doc2md !== false && envVar('NO_DOC2MD') !== '1',
       update: version ? readUpdateChip(version, { refresh: refreshUpdate }) : null,
       updatedAt: new Date() };
   };

package/src/commands/brief.js

@@ -23,6 +23,8 @@ export async function run({ hasFlag }) {
     }
     const ctx = readStdinJson() || {};
     const parts = [];
+    // Team prompt upload (Enterprise, opt-in): a stat-light gate, the work runs in a detached child.
+    try { (await import('../team-ratchet.js')).spawnTeamSyncOnPrompt(); } catch (e) { debug('brief:team-prompts', e); }
     try {
       const { runBrief } = await import('../brief.js');
       // `root` is the session's cwd for the same reason routeHint takes it below:

package/src/commands/codex.js

@@ -1,3 +1,4 @@
+import { envVar } from '../env.js';
 import { createArgs } from '../cli-args.js';
 import { configureCodexHooks } from '../codex/installer.js';
 import { initCodexHarness, uninitCodexHarness, codexHarnessStatus, syncCodexKoreanBlock } from '../codex/harness.js';
@@ -412,7 +413,7 @@ export async function run({ args, version }) {
     const hook = configureCodexHooks({ panelAuto });
     console.log(`Codex hooks: ${hook.file} (${hook.action})`);
     for (const line of describePanelSetup(panel)) console.log(`Codex ${line}`);
-    if (process.env.CTS_NO_HARNESS !== '1') {
+    if (envVar('NO_HARNESS') !== '1') {
       const h = initCodexHarness({ root, scope: 'global' });
       console.log(`Codex harness: ${h.file}`);
       try {
@@ -544,7 +545,7 @@ export async function run({ args, version }) {
     const { createRequire } = await import('node:module');
     const doc2md = createRequire(import.meta.url)('../doc2md.cjs');
     const { codexHookStatus } = await import('../codex/installer.js');
-    console.log(`Codex document conversion: ${loadConfig()?.codex?.doc2md === false || process.env.CTS_NO_DOC2MD === '1' ? 'off' : 'on'}`);
+    console.log(`Codex document conversion: ${loadConfig()?.codex?.doc2md === false || envVar('NO_DOC2MD') === '1' ? 'off' : 'on'}`);
     console.log(`Formats: ${doc2md.TARGET_EXTENSIONS.join(' ')}`);
     console.log(`Converter: ${doc2md.findInterpreter() || 'missing; run sprag doc2md install-converter --agent codex'}`);
     console.log(`Cache: ${doc2md.cacheDir()}`);

package/src/commands/harness.js

@@ -274,9 +274,8 @@ export async function run({ args, hasFlag }) {
         // Event-triggered refresh: establish the new rule's stat baseline
         // right away instead of waiting for the next data-gated rescan.
         try {
-          const { spawn } = await import('node:child_process');
-          spawn(process.execPath, [process.argv[1], 'route-scan', '--refresh', '--quiet'],
-            { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+          const { spawnDetachedCli } = await import('../cli-entry.js');
+          spawnDetachedCli(['route-scan', '--refresh', '--quiet']);
         } catch (e) { debug('promote:spawn-refresh', e); /* baseline arrives on the next gated rescan */ }
         return;
       }

package/src/commands/install.js

@@ -18,6 +18,7 @@
  * terminal (postinstall, CI, pipes) it keeps theirs, as before.
  */
 
+import { envVar } from '../env.js';
 import { debug } from '../debug.js';
 
 /** Thrown when the user declines an optional step, so it is not reported as a failure. */
@@ -50,7 +51,7 @@ export async function run({ hasFlag }) {
     // English — the one outcome a Korean-locale machine should not get by
     // default. Already decided means never asked again.
     try {
-      if (!languageDecided() && !process.env.CTS_LANG) {
+      if (!languageDecided() && !envVar('LANG')) {
         const { koreanLocaleDetected } = await import('../korean-style.js');
         const detected = koreanLocaleDetected() ? 'ko' : 'en';
         console.log('');
@@ -63,14 +64,14 @@ export async function run({ hasFlag }) {
         }
         setUserLanguage(chosen);
         console.log(`  language: set to ${chosen === 'ko' ? '한국어' : 'English'} — change it any time with \`sprag mode lang=${chosen === 'ko' ? 'en' : 'ko'}\``);
-      } else if (process.env.CTS_LANG) {
+      } else if (envVar('LANG')) {
         // Escape hatch for scripted installs, which cannot answer a prompt but
         // do know which language the machine's user reads.
-        const forced = setUserLanguage(process.env.CTS_LANG);
+        const forced = setUserLanguage(envVar('LANG'));
         console.log('');
         console.log(forced
-          ? `  language: set to ${forced} (CTS_LANG)`
-          : `  language: ignored CTS_LANG=${process.env.CTS_LANG} — use 'ko' or 'en'`);
+          ? `  language: set to ${forced} (SPRAG_LANG)`
+          : `  language: ignored SPRAG_LANG=${envVar('LANG')} — use 'ko' or 'en'`);
       }
     } catch (e) {
       debug('install:language', e); // the English fallback still works
@@ -166,16 +167,16 @@ export async function run({ hasFlag }) {
     // any one project, and the harness principles are project-independent.
     // Only ever ADDS — harnessInit appends its own marked block, backs up the
     // previous file, and leaves surrounding content untouched. Skipped when a
-    // block is already there (nothing to do) and when CTS_NO_HARNESS=1 is set,
+    // block is already there (nothing to do) and when SPRAG_NO_HARNESS=1 is set,
     // for anyone who wants the statusline without the CLAUDE.md rules.
     try {
       const { harnessInit, harnessStatus } = await import('../harness.js');
       const before = harnessStatus(undefined, { scope: 'global' });
-      if (process.env.CTS_NO_HARNESS === '1') {
+      if (envVar('NO_HARNESS') === '1') {
         console.log('');
         console.log(lang === 'ko'
-          ? '  harness: CTS_NO_HARNESS=1 이므로 건너뜁니다 (나중에 `harness init --global`).'
-          : '  harness: skipped (CTS_NO_HARNESS=1) — run `harness init --global` later.');
+          ? '  harness: SPRAG_NO_HARNESS=1 이므로 건너뜁니다 (나중에 `harness init --global`).'
+          : '  harness: skipped (SPRAG_NO_HARNESS=1) — run `harness init --global` later.');
       } else if (before.hasBlock) {
         console.log('');
         console.log(lang === 'ko'
@@ -242,11 +243,11 @@ export async function run({ hasFlag }) {
     // upgrade never re-enables something they turned off.
     try {
       const ks = await import('../korean-style.js');
-      if (process.env.CTS_NO_KOREAN === '1') {
+      if (envVar('NO_KOREAN') === '1') {
         console.log('');
         console.log(lang === 'ko'
-          ? '  korean: CTS_NO_KOREAN=1 이므로 건너뜁니다 (나중에 `korean on`).'
-          : '  korean: skipped (CTS_NO_KOREAN=1) — run `korean on` later.');
+          ? '  korean: SPRAG_NO_KOREAN=1 이므로 건너뜁니다 (나중에 `korean on`).'
+          : '  korean: skipped (SPRAG_NO_KOREAN=1) — run `korean on` later.');
       } else if (ks.koreanStyleDecided()) {
         console.log('');
         console.log(lang === 'ko'
@@ -328,11 +329,11 @@ export async function run({ hasFlag }) {
       const { createRequire } = await import('node:module');
       const require = createRequire(import.meta.url);
       const doc2md = require('../doc2md.cjs');
-      if (process.env.CTS_NO_DOC2MD === '1') {
+      if (envVar('NO_DOC2MD') === '1') {
         console.log('');
         console.log(lang === 'ko'
-          ? '  doc2md: CTS_NO_DOC2MD=1 이므로 건너뜁니다 (나중에 `doc2md on`).'
-          : '  doc2md: skipped (CTS_NO_DOC2MD=1) — run `doc2md on` later.');
+          ? '  doc2md: SPRAG_NO_DOC2MD=1 이므로 건너뜁니다 (나중에 `doc2md on`).'
+          : '  doc2md: skipped (SPRAG_NO_DOC2MD=1) — run `doc2md on` later.');
       } else {
         const { installDoc2mdHook } = await import('../installer.js');
         const res = installDoc2mdHook();
@@ -430,7 +431,7 @@ export async function run({ hasFlag }) {
     try {
       const { codexUserDir } = await import('../agent.js');
       const { existsSync } = await import('node:fs');
-      if (process.env.CTS_NO_CODEX !== '1' && existsSync(codexUserDir())) {
+      if (envVar('NO_CODEX') !== '1' && existsSync(codexUserDir())) {
         let proceed = true;
         if (interactive) {
           console.log('');
@@ -451,7 +452,7 @@ export async function run({ hasFlag }) {
             if (!tmuxAvailable() && !await confirm(lang === 'ko'
               ? '  codex: tmux 가 없습니다. Homebrew 로 설치해 같은 창에 패널을 붙일까요?'
               : '  codex: tmux is missing. Install it with Homebrew so the panel shares the Codex window?', { defaultValue: true })) {
-              env = { ...process.env, CTS_NO_TMUX: '1' };
+              env = { ...process.env, SPRAG_NO_TMUX: '1' };
             }
           }
           let panel;
@@ -465,7 +466,7 @@ export async function run({ hasFlag }) {
           console.log('');
           console.log(`  codex: hooks ${hook.action} (${hook.file})`);
           for (const line of describePanelSetup(panel, lang)) console.log(`  codex: ${line}`);
-          if (process.env.CTS_NO_HARNESS !== '1') {
+          if (envVar('NO_HARNESS') !== '1') {
             const h = initCodexHarness({ scope: 'global' });
             console.log(`  codex: harness ${h.file}`);
             try {