sprag-cli 3.75.1 → 3.76.0

package/docs/TEAM.ko.md

@@ -16,31 +16,32 @@ Sprag 은 기본적으로 로컬에서만 동작합니다. 팀 기능은 켜야
 | 모델 계열 비중 | 위임 실행 중 모델 계열별 비율 |
 | Sprag 버전 | 설치된 버전 |
 | 에이전트 | `claude` 또는 `codex` |
-| 표시 이름 | 참여할 때 정한 이름이며, 기본값은 OS 사용자 이름 |
-| 운영체제 | OS 이름과 버전(예: macOS 26, Windows 11, Ubuntu 24.04), CPU 아키텍처(arm64, x64)입니다. 참여한 직후 한 번 보내고, 바뀔 때만 다시 보냅니다. 호스트 이름, 사용자 이름, 경로처럼 컴퓨터를 이름으로 알아볼 수 있는 값은 보내지 않습니다 |
+| 표시 이름 | 참여할 때 정한 이름이며, 기본값은 컴퓨터마다 한 번 만드는 `member-3f9a2c71` 같은 무작위 구성원 ID |
+| 기기 ID | 위와 같은 무작위 구성원 ID입니다. 표시 이름을 바꿔도 참여할 때 함께 보내며, 같은 컴퓨터가 다시 참여하면 조직 안에서 기존 좌석을 그대로 쓰게 하는 데 씁니다 |
+| 운영체제 | OS 이름과 버전(예: macOS 26, Windows 11, Ubuntu 24.04)입니다. 참여한 직후 한 번 보내고, 바뀔 때만 다시 보냅니다. 호스트 이름, 사용자 이름, 경로처럼 컴퓨터를 이름으로 알아볼 수 있는 값은 보내지 않습니다 |
 
 보내지 않는 것은 프롬프트, 대화 기록, 파일 경로, 프로젝트 이름, 룰 내용, API 키입니다. 프롬프트 수집을 켠 엔터프라이즈 팀의 옵트인 프롬프트 업로드만 예외이며 "프롬프트 사용량 (엔터프라이즈)" 절에 적었습니다. 룰은 직접 `sprag team propose` 를 실행할 때만 밖으로 나갑니다.
 
 하루 단위 집계 업로드는 마지막 성공 이후 6시간에 한 번 이하로 실행됩니다. SessionStart 훅(그리고 작은 로컬 파일만 읽는 프롬프트 훅)이 띄운 분리된 자식 프로세스가 보냅니다. 네트워크가 끊기는 등 동기화가 실패하면 6시간을 기다리지 않고 15분, 30분, 60분 뒤에 다시 시도합니다(최대 60분 간격). 마지막으로 올린 날짜를 기억해 두었다가 그 전날부터 최대 30일 치를 다시 보내므로, 며칠 꺼져 있던 컴퓨터도 처음 성공하는 동기화에서 빠진 날을 따라잡습니다. 하루 단위 행은 덮어쓰기라 다시 보내도 안전합니다. 프롬프트 수집을 켠 엔터프라이즈 팀의 프롬프트 업로드는 따로 30분 타이머로 움직입니다("프롬프트 사용량 (엔터프라이즈)" 절 참고). 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`, `prompt_chunk_put`(엔터프라이즈 프롬프트 수집일 때만), `member_set_sync`(업로드 스위치 상태 호출, "업로드 스위치" 참고) 입니다.
+목적지는 `https://hiycfjwswtkixyoqkznm.supabase.co/rest/v1/rpc/*` 입니다(Supabase, ap-northeast-2 리전). 호출하는 RPC 는 `team_join`, `ledger_upsert`, `team_rules_get`, `team_rule_propose`, `team_leave`, `prompt_chunk_put`(엔터프라이즈 프롬프트 수집일 때만), `member_set_sync`(업로드 스위치 상태 호출, "업로드 스위치" 참고), `member_set_info`(OS 이름과 버전, `arch` 인자는 항상 빈 값) 입니다.
 
 ## CLI에서 팀 만들기
 
-웹 대시보드 없이 팀을 만들 수 있습니다. 로그인은 메일로 받는 6자리 코드(15분간 유효)로 하며, Sprag 은 로그인 세션을 저장하지 않습니다.
+웹 대시보드 없이도, 내가 오너나 어드민인 조직 안에 팀을 만들 수 있습니다. 조직 ID는 대시보드에 있고, 조직 개설은 Sprag가 합니다("조직과 좌석" 절 참고). 로그인은 메일로 받는 6자리 코드(15분간 유효)로 하며, Sprag 은 로그인 세션을 저장하지 않습니다.
 
 터미널에서는 명령 하나를 실행하고 묻는 대로 답하면 됩니다 (이메일, 코드, 팀 이름).
 
 ```bash
-sprag team create
+sprag team create --org <조직 ID>
 ```
 
 에이전트나 터미널이 없는 셸에서는 두 단계로 나눕니다.
 
 ```bash
-sprag team create --email you@example.com --name "Acme"
+sprag team create --org <조직 ID> --email you@example.com --name "Acme"
 # 메일로 코드가 오면 이어서 실행합니다
-sprag team create --email you@example.com --name "Acme" --code 123456
+sprag team create --org <조직 ID> --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/ 에 로그인하면 팀을 관리할 수 있습니다.
@@ -55,7 +56,7 @@ sprag team create --email you@example.com --name "Acme" --code 123456
 sprag team join <토큰> --name "미나"
 ```
 
-Sprag 이 올라갈 항목 목록을 보여 주고 확인을 묻습니다. `--name` 은 표시 이름이며 기본값은 OS 사용자 이름입니다. 터미널이 없는 셸에서는 `--yes` 를 붙여 확인을 대신합니다. 토큰을 생략하면 `SPRAG_TEAM_TOKEN` 을 읽습니다.
+Sprag 이 올라갈 항목 목록을 보여 주고 확인을 묻습니다. `--name` 은 표시 이름이며 기본값은 `member-3f9a2c71` 같은 무작위 구성원 ID입니다. 이 ID는 컴퓨터마다 한 번 만들어 사용자 데이터 디렉터리에 보관하며, `--name` 으로 바꿀 수 있습니다. 이 변경 전에 참여한 구성원은 서버에 이미 저장된 이름을 그대로 씁니다. 터미널이 없는 셸에서는 `--yes` 를 붙여 확인을 대신합니다. 토큰을 생략하면 `SPRAG_TEAM_TOKEN` 을 읽습니다.
 
 결과는 `sprag team status` 로 확인합니다.
 
@@ -99,14 +100,16 @@ Sprag 은 룰을 `~/.claude/ratchet-team.md`(Codex 는 `<CODEX_HOME>/ratchet-tea
 
 ## 조직과 좌석
 
-모든 팀은 조직에 속하고, 좌석은 팀이 아니라 조직 단위로 구매합니다. 조직을 지정하지 않고 만든 팀에는 조직이 자동으로 새로 생기므로 기존 설정은 그대로 동작합니다.
+모든 팀은 조직에 속하고, 좌석은 팀이 아니라 조직 단위로 구매합니다. 조직은 Sprag만 개설합니다. sales@sprag.io 로 문의하면 슈퍼유저가 sprag.io/ops/ 에서 조직을 열고 첫 오너를 지정하며, 그다음부터 오너와 어드민이 그 안에 팀을 만듭니다.
+
+컴퓨터 한 대는 조직마다 좌석 하나를 씁니다. `sprag team leave` 뒤에 다시 참여하거나, 재설치하거나, 같은 조직의 다른 팀 초대로 참여해도 서버가 기기 ID로 예전 행을 찾아 초대받은 팀으로 옮기고 멤버 키만 새로 발급합니다. 행도 좌석도 두 개가 되지 않습니다. 다른 조직에 참여하면 그 조직의 좌석을 따로 씁니다.
 
 - **좌석이란.** 팀을 떠나지 않았고, 최근 30일 안에 무엇이든 보냈거나 업로드를 멈춘 상태인 컴퓨터 한 대(멤버 키 하나)입니다. 멈추지 않았는데 30일 넘게 연락이 없는 컴퓨터는 좌석을 차지하지 않습니다. 떠난 멤버도 세지 않습니다.
 - **두 번째 컴퓨터.** 같은 사람이 컴퓨터 두 대를 쓰면 오너나 어드민이 두 번째 컴퓨터를 첫 번째에 합쳐 좌석 하나를 같이 쓰게 할 수 있습니다. 대시보드의 멤버 행에서 "좌석 합치기"를 누르고, "합치기 해제"를 누르면 다시 따로 셉니다. 합쳐진 행에는 "OO님과 자리를 같이 씁니다"가 보입니다.
 - **한도.** 조직마다 좌석 한도가 있고, 한도를 넘는 참여는 거절됩니다. `sprag team join` 은 "이 조직에 남은 좌석이 없습니다. 조직 오너나 어드민에게 좌석 추가를 요청한 뒤 다시 참여하세요"를 출력하고 종료 코드 1로 끝납니다. 환경 변수로 하는 자동 참여는 조용히 넘어갔다가 다음 세션 시작 때 다시 시도합니다. 한도를 현재 사용량보다 낮춰도 기존 멤버는 그대로 쓰고, Sprag가 다시 올릴 때까지 새 참여만 거절됩니다.
 - **역할.** 권한 단계는 세 가지입니다. 슈퍼유저는 Sprag 직원이며 요금제와 좌석 한도를 정하고, 조직을 정지하고, 오너를 추가하고, sprag.io/ops/ 에서 모든 조직을 봅니다. 오너는 회사의 최상위 단계로, 어드민을 지정하거나 해제하고 어드민이 하는 일을 모두 합니다. 어드민은 회사의 관리 단계로, 팀을 만들고 구성원과 룰과 좌석을 관리합니다. 팀을 만든 사람에게도 특별한 권한이 없으며, 팀은 조직의 오너와 어드민, 그리고 슈퍼유저만 관리합니다. 오너와 어드민은 대시보드에서 좌석 한도를 볼 수 있습니다. 좌석을 늘리려면 sales@sprag.io 로 문의합니다.
 
-기존 조직 안에 팀을 만들려면 `sprag team create --org <조직 ID>` 를 씁니다. 명령은 조직 이름과 사용 중인 좌석 수를 함께 출력하고, `sprag team status` 는 조직 이름을 보여 줍니다.
+관리하는 조직 안에 팀을 만들려면 `sprag team create --org <조직 ID>` 를 씁니다. 조직은 Sprag만 개설하므로 `--org` 없이 실행하면 서버가 거절합니다. 명령은 조직 이름과 사용 중인 좌석 수를 함께 출력하고, `sprag team status` 는 조직 이름을 보여 줍니다.
 
 ## 업로드 스위치
 

package/docs/TEAM.md

@@ -16,31 +16,32 @@ After you join, Sprag uploads one row per local calendar 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 |
-| Operating system | OS name and version (for example macOS 26, Windows 11, Ubuntu 24.04) and CPU architecture (arm64 or x64); sent once after joining and again only if it changes. Nothing that identifies the machine by name: no hostname, no user name, no path |
+| Display name | the name you chose at join; the default is a random member ID such as `member-3f9a2c71`, created once per machine |
+| Machine ID | the same random member ID, sent at join even when you choose another display name, so that a machine joining again reuses its seat in the organization instead of taking a second one |
+| Operating system | OS name and version (for example macOS 26, Windows 11, Ubuntu 24.04); sent once after joining and again only if it changes. Nothing that identifies the machine by name: no hostname, no user name, no path |
 
 Not sent: prompts, transcripts, file paths, project names, rule text, API keys. The one exception is the opt-in prompt upload of an Enterprise team with prompt capture on, described under "Prompt usage (Enterprise)". A rule leaves your machine only when you run `sprag team propose` yourself.
 
 The daily aggregate upload runs at most once every 6 hours after the last successful one, from a detached child process that the SessionStart hook (and the prompt hook, which only reads a small local file) spawns. If a sync fails, for example because the network is down, it is retried after 15, then 30, then 60 minutes (60 at most) instead of waiting 6 hours. The CLI remembers the last day it uploaded and re-sends from the day before it, up to 30 days, so a machine that was offline for days catches up on its first successful sync. Re-sending a day is safe because each day is an upsert. The prompt upload of an Enterprise team with capture on has its own 30-minute timer (see "Prompt usage (Enterprise)"). 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`, `team_leave`, `prompt_chunk_put` (Enterprise prompt capture only) and `member_set_sync` (the upload-switch status call, see "The upload switch"); `sprag team create` also calls `team_create` with your sign-in session.
+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`, `team_leave`, `prompt_chunk_put` (Enterprise prompt capture only), `member_set_sync` (the upload-switch status call, see "The upload switch") and `member_set_info` (OS name and version; the `arch` argument is always empty); `sprag team create` also calls `team_create` with your sign-in session.
 
 ## 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.
+You can set up a team without the web dashboard, inside an organization you own or administer (the organization id is in the dashboard; Sprag opens organizations, see "Organizations and seats"). 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
+sprag team create --org <org-id>
 ```
 
 From an agent or any shell without a terminal, it takes two steps:
 
 ```bash
-sprag team create --email you@example.com --name "Acme"
+sprag team create --org <org-id> --email you@example.com --name "Acme"
 # the code arrives by email, then:
-sprag team create --email you@example.com --name "Acme" --code 123456
+sprag team create --org <org-id> --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.
@@ -55,7 +56,7 @@ An owner or admin gives you an invite token. Then:
 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`.
+Sprag prints the list of what will be uploaded and asks for confirmation. `--name` sets the display name (default: a random member ID like `member-3f9a2c71`, created once per machine and kept in the user data dir, so it is the same on every join from that machine). Members who joined before this change keep the name already stored on the server. 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`.
 
@@ -99,7 +100,9 @@ Sprag writes the rules to `~/.claude/ratchet-team.md` (Codex: `<CODEX_HOME>/ratc
 
 ## Organizations and seats
 
-Every team belongs to an organization, and seats are bought per organization, not per team. Teams you create without naming an organization get a new one automatically, so existing setups keep working.
+Every team belongs to an organization, and seats are bought per organization, not per team. Only Sprag opens organizations: write to sales@sprag.io, and the superuser opens one at sprag.io/ops/ and names its first owner. Owners and admins then create teams inside it.
+
+A machine holds one seat per organization. When it joins again, with `sprag team join` after `sprag team leave`, after a reinstall, or with the invite of another team in the same organization, the server finds its earlier row by the machine ID, moves it to the invited team and issues a new member key; no second row and no second seat appear. Joins to a different organization take a seat there.
 
 - **What a seat is.** One machine (one member key) that has not left and either sent anything in the last 30 days or is paused. A machine that has been silent for 30 days or more without being paused holds no seat. Members who left are not counted.
 - **Second machine.** When the same person uses two machines, an owner or admin can merge the second one into the first so the two share one seat. In the dashboard, use "Merge seat" on the member row; "Unmerge" gives it its own seat back. A merged row shows "shares a seat with <name>".
@@ -107,7 +110,7 @@ Every team belongs to an organization, and seats are bought per organization, no
 - **Roles.** There are three permission levels. The superuser is Sprag staff: it sets the plan and the seat limit, suspends organizations, adds owners, and sees every organization at sprag.io/ops/. An owner is a company's top level: it appoints and removes admins, and does everything an admin does. An admin is a company's management level: it creates teams and manages members, rules and seats. The person who created a team has no special rights over it; only the organization's owners and admins and the superuser manage teams. Owners and admins see the seat limit in the dashboard. To add seats, write to sales@sprag.io.
 - **The plan.** Sprag sets the plan (`pro` or `enterprise`) on the organization; owners and admins cannot change it. Prompt capture can be switched on only while the organization is on Enterprise. To change the plan, contact us.
 
-Create a team inside an existing organization from the CLI with `sprag team create --org <org-id>`. The command prints the organization name and how many seats are used. `sprag team status` shows the organization name.
+Create a team inside an organization you administer from the CLI with `sprag team create --org <org-id>`; without `--org` the server refuses, because only Sprag opens organizations. The command prints the organization name and how many seats are used. `sprag team status` shows the organization name.
 
 ## The upload switch
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.75.1",
+  "version": "3.76.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": {

package/src/commands/team.js

@@ -10,9 +10,9 @@
 
 import { createInterface } from 'node:readline';
 import { readFileSync } from 'node:fs';
-import { userInfo } from 'node:os';
 import { userLanguage } from '../config.js';
 import { pendingPrompts } from '../team-prompts.js';
+import { memberId } from '../member-id.js';
 import {
   loadTeamState, deviceInfo, isJoined, joinTeam, leaveTeam, syncTeam, autoJoin, aggregateDaily, rpc,
   teamRulesCachePath, teamSyncDisabled, requestSignInCode, verifySignInCode, createTeam, isSeatLimitError,
@@ -33,6 +33,7 @@ const T = {
     ].join('\n'),
     willSend: 'Joining uploads daily aggregates only, per local day:\n  - spend (USD)\n  - savings (USD)\n  - delegation run counts\n  - model-family share\nNo prompts, file paths or transcripts are sent.',
     asName: (n) => `Display name: ${n}`,
+    asDevice: (d) => `Machine ID: ${d} (lets the organization count this machine once if it joins again)`,
     ask: 'Join? [y/N] ',
     needYes: 'Not a terminal. Re-run with --yes to confirm: sprag team join <token> --yes',
     noToken: 'Missing invite token. Pass it as an argument or set SPRAG_TEAM_TOKEN.',
@@ -43,6 +44,7 @@ const T = {
     seats: (u, l) => `${u}/${l} seats used`,
     orgCreated: (n, u, l) => `Organization: ${n}${u != null && l != null ? ` (${u}/${l} seats used)` : ''}`,
     badOrg: '--org needs an organization id.',
+    noOrgCreate: 'Only Sprag opens new organizations. Pass --org <id> for an organization you administer (the id is on the dashboard), or write to sales@sprag.io to open one.',
     left: 'Left the team. Nothing is uploaded any more.',
     notJoined: 'Not in a team. Join with: sprag team join <token>',
     team: 'Team', plan: 'Plan', capture: 'Prompt capture', name: 'Display name',
@@ -96,6 +98,7 @@ const T = {
     ].join('\n'),
     willSend: '참여하면 로컬 날짜별 하루 단위 집계만 올라갑니다.\n  - 지출(USD)\n  - 절감(USD)\n  - 위임 실행 횟수\n  - 모델 계열 비중\n프롬프트, 파일 경로, 대화 기록은 보내지 않습니다.',
     asName: (n) => `표시 이름: ${n}`,
+    asDevice: (d) => `기기 ID: ${d} (다시 참여해도 조직이 이 컴퓨터를 한 좌석으로 셉니다)`,
     ask: '참여할까요? [y/N] ',
     needYes: '터미널이 아닙니다. 확인하려면 --yes 를 붙여 다시 실행하세요: sprag team join <토큰> --yes',
     noToken: '초대 토큰이 없습니다. 인자로 넘기거나 SPRAG_TEAM_TOKEN 을 설정하세요.',
@@ -106,6 +109,7 @@ const T = {
     seats: (u, l) => `좌석 ${u}/${l} 사용 중`,
     orgCreated: (n, u, l) => `조직: ${n}${u != null && l != null ? ` (좌석 ${u}/${l} 사용 중)` : ''}`,
     badOrg: '--org 에는 조직 ID 가 필요합니다',
+    noOrgCreate: '새 조직은 Sprag가 개설합니다. 관리하는 조직이 있으면 --org <ID> 를 붙여 주세요(ID 는 대시보드에 있습니다). 조직 개설은 sales@sprag.io 로 문의해 주세요.',
     left: '팀에서 나왔습니다. 이제 아무것도 업로드하지 않습니다.',
     notJoined: '참여한 팀이 없습니다. 참여하려면: sprag team join <토큰>',
     team: '팀', plan: '플랜', capture: '프롬프트 수집', name: '표시 이름',
@@ -191,9 +195,7 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   if (!email) { console.error(m.needEmail); return process.exit(2); }
   if (!EMAIL_RE.test(email)) { console.error(m.badEmail); return process.exit(2); }
 
-  let osName = 'my';
-  try { osName = userInfo().username || 'my'; } catch { /* no passwd entry */ }
-  const defaultName = `${osName}'s team`;
+  const defaultName = `${memberId()}'s team`;
 
   let useCode = code;
   if (!useCode) {
@@ -212,7 +214,13 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   if (!name) { console.error(m.needName); return process.exit(2); }
 
   const { accessToken, userId } = await verifySignInCode({ email, code: useCode, fetch });
-  const team = await createTeam({ name, accessToken, userId, orgId: org || null, fetch });
+  let team;
+  try {
+    team = await createTeam({ name, accessToken, userId, orgId: org || null, fetch });
+  } catch (e) {
+    if (/only Sprag operators/i.test(String(e && e.message))) { console.error(m.noOrgCreate); return process.exit(1); }
+    throw e;
+  }
   out(m.created(team.name || name));
   if (team.orgName && noJoin) out(m.orgCreated(team.orgName, null, null));
   out(`${m.inviteToken}: ${team.inviteToken}`);
@@ -221,8 +229,7 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   out(m.dashboard(email));
 
   if (noJoin) { out(m.noJoinNote); return undefined; }
-  let display = 'member';
-  try { display = userInfo().username || 'member'; } catch { /* no passwd entry */ }
+  const display = memberId();
   const joined = await joinTeam({ token: team.inviteToken, displayName: display, fetch, version });
   if (joined.orgName && joined.seatsUsed != null && joined.seatLimit != null) out(m.orgCreated(joined.orgName, joined.seatsUsed, joined.seatLimit));
   if (!teamSyncDisabled()) {
@@ -248,14 +255,15 @@ export async function run({ args, hasFlag, getArg, version, fetch, interactive,
         const token = (args[2] && !args[2].startsWith('--') ? args[2] : null) || process.env.SPRAG_TEAM_TOKEN;
         if (!token) { console.error(m.noToken); return process.exit(2); }
         let name = getArg('--name');
-        if (!name) { try { name = userInfo().username; } catch { name = 'member'; } }
+        if (!name) name = memberId();
         out(m.willSend);
         out(m.asName(name));
+        out(m.asDevice(memberId()));
         if (!hasFlag('--yes')) {
           if (!process.stdin.isTTY || !process.stdout.isTTY) { console.error(m.needYes); return process.exit(2); }
           if (!(await confirm(m.ask))) { out(m.aborted); return undefined; }
         }
-        const st = await joinTeam({ token, displayName: name, version });
+        const st = await joinTeam({ token, displayName: name, fetch, version });
         out(m.joined(st.teamName));
         if (st.orgName && st.seatsUsed != null && st.seatLimit != null) out(m.orgCreated(st.orgName, st.seatsUsed, st.seatLimit));
         return undefined;

package/src/member-id.js

@@ -0,0 +1,64 @@
+/**
+ * member-id — the default display name for the team layer.
+ *
+ * The OS login name used to fill this slot, which sent a real username to the
+ * team server. A random id created once per machine names the member without
+ * naming the person. It lives in its own file in the user data dir, so
+ * `team leave` (which only touches team.json) keeps it and a rejoin on the same
+ * machine shows up under the same name.
+ *
+ * One id per machine holds even when things go wrong: an id that could not be
+ * written is remembered for the life of the process, and a missing file is
+ * created exclusively (temp file + hard link), so two processes starting at
+ * once end up with the id of whichever linked first.
+ */
+
+import { readFileSync, existsSync, mkdirSync, writeFileSync, linkSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { userDataDir } from './paths.js';
+import { writeStateFile } from './state-file.js';
+import { debug } from './debug.js';
+
+const ID_RE = /^member-[0-9a-f]{8}$/;
+const cache = new Map();
+
+export const memberIdPath = (dir = userDataDir()) => join(dir, 'member-id');
+
+function readValid(file) {
+  try {
+    const text = readFileSync(file, 'utf8').trim();
+    return ID_RE.test(text) ? text : null;
+  } catch (e) { debug('member-id', e); return null; }
+}
+
+// Never throws: a failed write still returns the id it generated, and the
+// cache hands the same one back on the next call.
+export function memberId({ dir = userDataDir(), random = () => randomBytes(4).toString('hex') } = {}) {
+  const file = memberIdPath(dir);
+  const existing = readValid(file);
+  if (existing) { cache.set(file, existing); return existing; }
+  let id = cache.get(file) || `member-${random()}`;
+  try {
+    if (existsSync(file)) {
+      writeStateFile(file, `${id}\n`);
+    } else {
+      mkdirSync(dirname(file), { recursive: true });
+      const tmp = `${file}.${process.pid}.tmp`;
+      try {
+        writeFileSync(tmp, `${id}\n`);
+        linkSync(tmp, file);
+      } catch (e) {
+        // A file system without hard links still gets the file, just not exclusively.
+        if (e.code !== 'EEXIST') { debug('member-id', e); writeStateFile(file, `${id}\n`); } else {
+          const winner = readValid(file); // another process created it first
+          if (winner) id = winner;
+        }
+      } finally {
+        try { unlinkSync(tmp); } catch { /* never created */ }
+      }
+    }
+  } catch (e) { debug('member-id', e); }
+  cache.set(file, id);
+  return id;
+}

package/src/team-sync.js

@@ -24,10 +24,11 @@ import { envVar } from './env.js';
 import { readFileSync, existsSync, rmSync, chmodSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
-import { userInfo, release as osRelease } from 'node:os';
+import { release as osRelease } from 'node:os';
 import { createRequire } from 'node:module';
 import { userDataDir } from './paths.js';
 import { writeStateFile } from './state-file.js';
+import { memberId } from './member-id.js';
 import { debug } from './debug.js';
 import { loadLedger, modelFamily, roundUsd } from './savings-ledger.js';
 import { sessionCost, pricedParts } from './claude-price.js';
@@ -330,12 +331,14 @@ export async function aggregateDaily({ now = Date.now(), dir = userDataDir(), da
     }));
 }
 
-// Device info: OS name, OS version and CPU architecture. Nothing that names the
-// machine (no hostname, username or path) is read or sent.
+// Device info: OS name and OS version. The CPU architecture is not sent: the
+// `arch` key stays in the payload (the member_set_info RPC takes it as an
+// argument) but is always empty. Nothing that names the machine (no hostname,
+// username or path) is read or sent.
 const DARWIN_TO_MACOS = { 20: '11', 21: '12', 22: '13', 23: '14', 24: '15', 25: '26' };
 
 export function deviceInfo({
-  platform = process.platform, arch = process.arch, release = osRelease(),
+  platform = process.platform, release = osRelease(),
   exec = (cmd, args) => execFileSync(cmd, args, { timeout: 2000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }),
   readText = (f) => readFileSync(f, 'utf8'),
 } = {}) {
@@ -363,7 +366,7 @@ export function deviceInfo({
       } catch (e) { debug('team-sync', e); }
     }
   } catch (e) { debug('team-sync', e); }
-  return { os: os.slice(0, 40), os_version: osVersion.slice(0, 40), arch: String(arch).slice(0, 40) };
+  return { os: os.slice(0, 40), os_version: osVersion.slice(0, 40), arch: '' };
 }
 
 // Reports device info once after a join and again only when it changes. Fails
@@ -387,12 +390,20 @@ export async function joinTeam({
   token, displayName, agent = 'claude', autoJoined = false, fetch, dir = userDataDir(), version, now = Date.now(), env = process.env,
 } = {}) {
   if (!TOKEN_RE.test(String(token || ''))) throw new Error('invalid invite token (expected spt_ + 32 hex characters)');
-  const name = String(displayName || '').trim() || 'member';
+  const device = memberId({ dir });
+  const name = String(displayName || '').trim() || device;
+  const params = { invite_token: token, display_name: name, agent, sprag_version: version || '', auto_joined: !!autoJoined };
   let r;
   try {
-    r = await rpc('team_join', {
-      invite_token: token, display_name: name, agent, sprag_version: version || '', auto_joined: !!autoJoined,
-    }, { fetch });
+    // device_id lets the server find this machine's earlier row in the organization and reuse its seat
+    // instead of adding a second one. A server older than that answers "Could not find the function";
+    // the join is then repeated without it.
+    try {
+      r = await rpc('team_join', { ...params, device_id: device }, { fetch });
+    } catch (e) {
+      if (!/device_id|Could not find the function|PGRST202/i.test(String(e && e.message))) throw e;
+      r = await rpc('team_join', params, { fetch });
+    }
   } catch (e) {
     if (isSeatLimitError(e)) throw new SeatLimitError(e.message);
     throw e;
@@ -604,8 +615,7 @@ export async function autoJoin({ env = process.env, fetch, dir = userDataDir(),
   // A state with `left: true` never auto-rejoins: leaving must beat the
   // environment, or `sprag team leave` would be undone by the next session.
   if (isJoined(state) || state.left) return null;
-  let name = 'member';
-  try { name = userInfo().username || 'member'; } catch { /* no passwd entry */ }
+  const name = memberId({ dir });
   try {
     return await joinTeam({ token, displayName: name, autoJoined: true, fetch, dir, version, now, env });
   } catch (e) {

package/src/update-check.js

@@ -29,12 +29,19 @@
  * once-a-day pass as the version check, and its absence never blocks the
  * notice — a version number alone is still worth saying.
  *
+ * The version is asked of the npm registry the user has configured
+ * (npm_config_registry, then the `registry=` line of ~/.npmrc, then
+ * registry.npmjs.org), so a machine behind a corporate mirror checks the
+ * mirror instead of a host it may not be able to reach. A mirror that fails is
+ * reported as a failure; there is no silent fallback to npmjs.
+ *
  * Opt out with SPRAG_NO_UPDATE_CHECK=1 or NO_UPDATE_NOTIFIER (the de-facto
  * standard env var — anyone who set it for other CLIs meant us too).
  */
 
 import { envVar } from './env.js';
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { join, dirname, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -334,6 +341,48 @@ function releaseTagUrl(version) {
   return url;
 }
 
+/**
+ * The npm registry base URL the user has configured. Order: the
+ * npm_config_registry env var (either case), the `registry=` line of
+ * ~/.npmrc, then the public registry. `@scope:registry=` lines are ignored:
+ * they route other packages, not this one.
+ */
+export function npmRegistry({
+  env = process.env, readText = (f) => readFileSync(f, 'utf8'), home = homedir(),
+} = {}) {
+  const unquote = (v) => v.trim().replace(/^(["'])(.*)\1$/, '$2');
+  const fromEnv = unquote(env.npm_config_registry || env.NPM_CONFIG_REGISTRY || '');
+  if (fromEnv) return fromEnv;
+  try {
+    for (const raw of readText(join(home, '.npmrc')).split(/\r?\n/)) {
+      const line = raw.trim();
+      if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+      const m = line.match(/^registry\s*=\s*(.+)$/);
+      if (m && unquote(m[1])) return unquote(m[1]);
+    }
+  } catch (e) { debug('update-check:npmrc', e); }
+  return 'https://registry.npmjs.org/';
+}
+
+/**
+ * The `latest` dist-tag URL under a registry base, or a throw. The base comes
+ * from the environment or a config file, so it is checked rather than trusted:
+ * https only, and the parsed result must still sit under the base (`new URL`
+ * has collapsed any `../` by then, so the prefix test runs on the parsed href).
+ */
+export function latestUrl(registry) {
+  const base = new URL(String(registry).endsWith('/') ? String(registry) : `${registry}/`);
+  if (base.protocol !== 'https:') {
+    // origin has no userinfo; it is "null" for non-http(s) schemes
+    throw new Error(`refusing to request ${base.origin === 'null' ? base.protocol : base.origin}: registry must use https`);
+  }
+  const url = new URL(`${CANONICAL_NAME}/latest`, base);
+  if (!url.href.startsWith(base.href)) {
+    throw new Error(`refusing to request ${url.origin}${url.pathname}: outside the registry base`);
+  }
+  return url;
+}
+
 /**
  * Fetch the highlights for one version. Returns [] on any failure: the notice
  * is worth showing with a bare version number, so a missing release, a rate
@@ -370,13 +419,16 @@ export async function fetchHighlights(version, { timeoutMs = FETCH_TIMEOUT_MS, l
  * Actually hit the registry and persist the answer. Only the detached child
  * and the explicit `update-check --refresh` command call this.
  */
-export async function refreshUpdateState(currentVersion) {
+export async function refreshUpdateState(currentVersion, { env, home } = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   try {
     // The `latest` dist-tag endpoint returns a few hundred bytes, unlike the
     // full packument which is megabytes for a package with this many releases.
-    const res = await fetch(`https://registry.npmjs.org/${CANONICAL_NAME}/latest`, {
+    // The URL is a checked https registry base plus a constant package path.
+    // Same scanner false positive as the releases request above.
+    // nosemgrep: rules.lgpl.nodejs_scan.javascript-ssrf-rule-node_ssrf
+    const res = await fetch(latestUrl(npmRegistry({ env, home })), {
       signal: controller.signal,
       headers: { accept: 'application/json' },
     });