sprag-cli 3.70.0 → 3.71.0

package/src/seed-rules.js

@@ -12,6 +12,8 @@
  * This module closes that gap with presets bundled in the package:
  *   presets/model-rules.json   → tier-delegation rules (the model ratchet)
  *   presets/ratchet-rules.json → field-tested mistake rules (the global ratchet)
+ * or, when one has been fetched and verifies, the centrally published bundle
+ * with the same shape (presets-source.js).
  *
  * Nothing is written without the user agreeing to that specific rule. The
  * SessionStart hook lists what is pending and tells the model to ask one rule at
@@ -25,9 +27,8 @@
 
 import { readFileSync } from 'node:fs';
 import { CLI_NAME } from './cli-name.js';
-import { join, dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { modelPresets as sourceModelPresets } from './presets-source.js';
 import { sharedModelRulesForProject, loadSharedModelRules, sharedProjectRoots, realProjectRoot } from './shared-model-rules.js';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
@@ -45,8 +46,6 @@ import {
   presetRuleEntries,
 } from './harness.js';
 
-const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
-
 // Codex answers are kept apart: saying no in one agent must not consume the
 // other agent's offer, and the two agents write to different ratchet files.
 export function seedStatePath({ agent = 'claude' } = {}) {
@@ -66,14 +65,12 @@ export function saveSeedState(state, opts = {}) {
   writeStateFile(seedStatePath(opts), JSON.stringify(state, null, 2) + '\n');
 }
 
-/** Bundled tier-delegation presets (empty array when the file is unreadable). */
+/**
+ * Tier-delegation presets: the published bundle when it verifies, else the
+ * bundled presets/model-rules.json (empty array when that is unreadable).
+ */
 export function modelPresets() {
-  try {
-    const data = JSON.parse(readFileSync(join(packageRoot, 'presets', 'model-rules.json'), 'utf8'));
-    return Array.isArray(data.presets) ? data.presets : [];
-  } catch {
-    return [];
-  }
+  return sourceModelPresets();
 }
 
 /**
@@ -87,10 +84,11 @@ export function ratchetPresets(lang = userLanguage(), { agent = 'claude' } = {})
     // tiers would only mislead a Codex session.
     .filter((r) => !r.agents || r.agents.includes(agent))
     .map((r) => ({
-      // Hashed from the Korean text in both languages: the id has to survive a
-      // reworded translation, or a user who declined a rule would be asked again
-      // the next time its English copy changes.
-      id: `fix-${createHash('sha1').update(r.ko).digest('hex').slice(0, 6)}`,
+      // The id is carried by the preset itself: first derived from the Korean
+      // text, then kept when a published bundle rewords the rule, so a user who
+      // accepted or declined it keeps that answer. presets-source.js fills it in
+      // for an entry that has none, from the Korean text as before.
+      id: r.id,
       text: lang === 'ko' ? r.ko : r.en,
       ko: r.ko,
     }));

package/src/star-note.js

@@ -8,10 +8,11 @@
  *
  * Once, because a chip that keeps asking is an advertisement. For 24 hours,
  * which is long enough to be seen across a day of sessions and short enough
- * not to linger. CTS_NO_NOTE=1 suppresses it, the same opt-out as every
+ * not to linger. SPRAG_NO_NOTE=1 suppresses it, the same opt-out as every
  * other one-time note.
  */
 
+import { envVar } from './env.js';
 import { createRequire } from 'node:module';
 import { delegationSavedTotals } from './savings-ledger.js';
 import { noteShownAt, markNoteShown } from './first-run-note.js';
@@ -43,7 +44,7 @@ export function toolSavedUsd(now = Date.now(), dir = userDataDir()) {
 /** `{ usd, shownAt }` while the chip should show, else null. Never throws. */
 export function readStarChip({ now = Date.now(), dir = userDataDir(), savedUsd } = {}) {
   try {
-    if (process.env.CTS_NO_NOTE === '1') return null;
+    if (envVar('NO_NOTE') === '1') return null;
     const shownAt = noteShownAt('star');
     if (shownAt === null) {
       const usd = savedUsd ?? toolSavedUsd(now, dir);

package/src/statusline-guard.js

@@ -0,0 +1,144 @@
+/**
+ * Overlap guard for the statusline command.
+ *
+ * Claude Code relaunches the statusline command every refreshInterval (5s)
+ * without checking whether the previous run has finished. Measured with a
+ * 20-second command: 15 processes were alive at once after 75 seconds. On a
+ * busy machine one render can exceed 5s, so processes pile up without bound
+ * (each is 170-320MB) and memory climbs until the machine stalls.
+ *
+ * Two defences live here: a per-session lock so a second run exits at once
+ * (printing the last good line), and a hard time budget after which a slow run
+ * prints the last good line and exits. Nothing here may ever throw or break
+ * the statusline: every filesystem failure degrades to "no guard".
+ */
+
+import { openSync, writeSync, closeSync, readFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { userDataDir } from './paths.js';
+import { extractSessionId } from './stdin-payload.js';
+import { writeStateFile } from './state-file.js';
+import { envVar } from './env.js';
+
+const LOCK_DIR = 'statusline-locks';
+const LAST_FILE = 'statusline-last.json';
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/** Default liveness probe: signal 0 checks existence without sending anything. */
+export function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return !(e && e.code === 'ESRCH');
+  }
+}
+
+export function sessionKeyFrom(stdinJson) {
+  const id = extractSessionId(stdinJson);
+  if (!id) return 'default';
+  const key = id.replace(/[^A-Za-z0-9_-]/g, '').slice(0, 64);
+  return key || 'default';
+}
+
+function readHolder(path) {
+  try {
+    const h = JSON.parse(readFileSync(path, 'utf8'));
+    if (h && typeof h === 'object' && Number.isFinite(h.pid) && Number.isFinite(h.startedAt)) return h;
+  } catch { /* unreadable or broken: treated as stale by the caller */ }
+  return null;
+}
+
+function tryCreate(path, pid, now) {
+  const fd = openSync(path, 'wx');
+  try {
+    writeSync(fd, JSON.stringify({ pid, startedAt: now }));
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export function acquireStatuslineLock({
+  dir = userDataDir(), key = 'default', now = Date.now(), pid = process.pid,
+  isAlive = defaultIsAlive, staleMs = 30_000, registerExit = true,
+} = {}) {
+  const noop = { acquired: true, release() {} };
+  try {
+    const lockDir = join(dir, LOCK_DIR);
+    mkdirSync(lockDir, { recursive: true });
+    const path = join(lockDir, `${key}.lock`);
+    const release = () => {
+      try {
+        const h = readHolder(path);
+        if (h && h.pid === pid) unlinkSync(path);
+      } catch { /* already gone */ }
+    };
+    const success = () => {
+      if (registerExit) process.once('exit', release);
+      return { acquired: true, path, release };
+    };
+    try {
+      tryCreate(path, pid, now);
+      return success();
+    } catch (e) {
+      if (!e || e.code !== 'EEXIST') return noop;
+    }
+    const holder = readHolder(path);
+    const stale = !holder || !isAlive(holder.pid) || now - holder.startedAt > staleMs;
+    if (!stale) return { acquired: false, holder };
+    try { unlinkSync(path); } catch { /* someone else removed it */ }
+    try {
+      tryCreate(path, pid, now);
+      return success();
+    } catch (e) {
+      if (!e || e.code !== 'EEXIST') return noop;
+      return { acquired: false, holder: readHolder(path) };
+    }
+  } catch {
+    return noop;
+  }
+}
+
+function readLastMap(dir) {
+  try {
+    const m = JSON.parse(readFileSync(join(dir, LAST_FILE), 'utf8'));
+    return m && typeof m === 'object' && !Array.isArray(m) ? m : {};
+  } catch {
+    return {};
+  }
+}
+
+export function readLastRender({ dir = userDataDir(), key = 'default' } = {}) {
+  try {
+    const entry = readLastMap(dir)[key];
+    return entry && typeof entry.text === 'string' ? entry.text : null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeLastRender({
+  dir = userDataDir(), key = 'default', text, now = Date.now(), maxAgeMs = DAY_MS,
+} = {}) {
+  try {
+    const map = readLastMap(dir);
+    for (const [k, v] of Object.entries(map)) {
+      if (!v || typeof v.at !== 'number' || now - v.at > maxAgeMs) delete map[k];
+    }
+    map[key] = { text, at: now };
+    writeStateFile(join(dir, LAST_FILE), JSON.stringify(map));
+  } catch { /* the cache is a convenience */ }
+}
+
+export function statuslineBudgetMs(env = process.env) {
+  const raw = envVar('STATUSLINE_BUDGET_MS', env);
+  if (typeof raw === 'string' && /^\d+$/.test(raw.trim())) return Number(raw.trim());
+  return 4000;
+}
+
+export function armStatuslineDeadline({ budgetMs, onExpire }) {
+  if (!budgetMs) return null;
+  const timer = setTimeout(onExpire, budgetMs);
+  timer.unref();
+  return timer;
+}

package/src/stdin-payload.js

@@ -4,7 +4,8 @@
  * else in the CLI takes the extracted values.
  */
 
-import { readFileSync } from 'node:fs';
+import { readSync } from 'node:fs';
+import { isatty } from 'node:tty';
 
 /**
  * Read the JSON blob Claude Code feeds the statusline command on stdin.
@@ -30,12 +31,40 @@ import { readFileSync } from 'node:fs';
 // command, so the raw text is read on first use and cached for the process.
 let rawCache = null;
 
+// The TTY test goes through isatty(0), never process.stdin: touching that
+// getter builds a stream that switches a pipe to non-blocking mode, and
+// readFileSync(0) then throws EAGAIN whenever the writer has not written yet.
+// Under load that dropped the whole payload (session id, rate limits, model)
+// on a random refresh. EAGAIN is still retried below for the same reason, in
+// case some other module touches process.stdin first.
+const STDIN_WAIT_MS = 2000;
+const sleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+function readFd0() {
+  const chunks = [];
+  const buf = Buffer.alloc(65536);
+  const deadline = Date.now() + STDIN_WAIT_MS;
+  for (;;) {
+    let n;
+    try {
+      n = readSync(0, buf, 0, buf.length, null);
+    } catch (e) {
+      if (e && e.code === 'EAGAIN' && Date.now() < deadline) { sleep(5); continue; }
+      if (e && e.code === 'EOF') break; // Windows reports a closed pipe this way
+      throw e;
+    }
+    if (n === 0) break;
+    chunks.push(Buffer.from(buf.subarray(0, n)));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
 /** The raw stdin text, read once. '' when stdin is a TTY or empty. */
 export function readStdinRaw() {
   if (rawCache !== null) return rawCache;
-  if (process.stdin.isTTY) return (rawCache = '');
+  if (isatty(0)) return (rawCache = '');
   try {
-    rawCache = readFileSync(0, 'utf8') || '';
+    rawCache = readFd0() || '';
   } catch {
     rawCache = '';
   }
@@ -43,7 +72,7 @@ export function readStdinRaw() {
 }
 
 export function readStdinJson() {
-  if (process.stdin.isTTY) return null;
+  if (isatty(0)) return null;
   try {
     const raw = readStdinRaw();
     if (!raw || !raw.trim()) return null;

package/src/team-prompts.js

@@ -0,0 +1,353 @@
+/**
+ * team-prompts — the Enterprise prompt uploader.
+ *
+ * Runs inside syncTeam only when the team's policy has prompt capture on (the
+ * server sends prompt_capture = true, and only for Enterprise organizations).
+ * What leaves the machine: the prompts the user typed in their own main
+ * sessions (Claude Code transcripts and Codex sessions), each as
+ * { at, project (a directory basename), text }, with obvious secrets replaced
+ * by "[redacted]". Never sent: assistant replies, tool output, file contents,
+ * subagent transcripts, slash-command wrappers, system reminders, local paths.
+ *
+ * Consent boundary: the first time a machine sees capture on, every existing
+ * transcript's offset is set to its current size, so history written before the
+ * policy reached this machine is never uploaded. Files created later start at 0.
+ * Turning capture off deletes the offsets file, so turning it on again starts
+ * fresh at the end of every file.
+ *
+ * Incremental by byte offset (prompts-offsets.json: { [path]: { offset, size, ino } }).
+ * The stored offset advances only after the server accepted the chunk or said
+ * it already had it. The path never leaves the machine: file_key is the first
+ * 16 hex chars of sha256(path).
+ */
+
+import { createHash } from 'node:crypto';
+import { openSync, readSync, closeSync, fstatSync, readdirSync, statSync, readFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { claudeUserDir, userDataDir } from './paths.js';
+import { codexUserDir } from './agent.js';
+import { discoverCodexSessionFiles } from './codex/parser.js';
+import { writeStateFile } from './state-file.js';
+import { debug } from './debug.js';
+
+export const MAX_RUN_PROMPTS = 2000;
+export const MAX_RUN_BYTES = 8 * 1024 * 1024;
+export const MAX_CHUNK_PROMPTS = 500;
+const MAX_CHUNK_CHARS = 1800000; // server cap is 2,000,000
+const MAX_TEXT = 20000;
+const READ_WINDOW = 16 * 1024 * 1024;
+const READ_WINDOW_MAX = 256 * 1024 * 1024;
+
+export const promptOffsetsPath = (dir = userDataDir()) => join(dir, 'prompts-offsets.json');
+
+// ---------------------------------------------------------------------------
+// Redaction
+// ---------------------------------------------------------------------------
+
+const REDACTED = '[redacted]';
+const SECRET_PATTERNS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*$/g, // key block cut off by the end of the prompt
+  /\bsk-ant-[A-Za-z0-9_-]{16,}/g,
+  /\bsk-[A-Za-z0-9_-]{20,}/g,
+  /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bxox[abpr]-[A-Za-z0-9-]{10,}/g,
+];
+
+/** Replace obvious secrets with "[redacted]". Conservative: it may over-redact, never under-redact these shapes. */
+export function redactSecrets(text) {
+  let s = String(text ?? '');
+  for (const re of SECRET_PATTERNS) s = s.replace(re, REDACTED);
+  s = s.replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{16,}/gi, `$1${REDACTED}`);
+  s = s.replace(
+    /\b([A-Za-z0-9_]*(?:KEY|TOKEN|PASSWORD|PASSWD|SECRET)[A-Za-z0-9_]*)(\s*=\s*)("[^"\n]*"|'[^'\n]*'|[^\s"']+)/gi,
+    (m, name, eq, val) => (val === REDACTED ? m : `${name}${eq}${REDACTED}`),
+  );
+  return s;
+}
+
+// ---------------------------------------------------------------------------
+// Prompt extraction
+// ---------------------------------------------------------------------------
+
+const basenameOf = (p) => {
+  const s = String(p ?? '').replace(/[\\/]+$/, '');
+  return s.slice(Math.max(s.lastIndexOf('/'), s.lastIndexOf('\\')) + 1).slice(0, 80);
+};
+
+const WRAPPER_RE = /<(?:command-name|command-message|command-args|local-command-stdout|local-command-stderr|local-command-caveat)>/;
+const REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+
+/** Strip reminders, drop wrappers and injected context; null when nothing user-typed is left. */
+function cleanPrompt(raw) {
+  if (typeof raw !== 'string') return null;
+  if (WRAPPER_RE.test(raw)) return null;
+  const text = raw.replace(REMINDER_RE, '').trim();
+  if (!text) return null;
+  if (text.startsWith('[Request interrupted by user')) return null;
+  return redactSecrets(text).slice(0, MAX_TEXT);
+}
+
+const textParts = (content) => (Array.isArray(content) ? content : [])
+  .filter((c) => c && c.type !== 'tool_result' && typeof c.text === 'string').map((c) => c.text).join('\n');
+
+/** One Claude Code transcript line -> { at, project, text } or null. */
+export function claudePromptFromLine(line) {
+  let e;
+  try { e = JSON.parse(line); } catch { return null; }
+  if (!e || e.type !== 'user' || e.isMeta || e.isSidechain || e.isCompactSummary || e.isVisibleInTranscriptOnly) return null;
+  const c = e.message?.content;
+  const text = cleanPrompt(typeof c === 'string' ? c : textParts(c));
+  const at = Date.parse(e.timestamp);
+  if (!text || !Number.isFinite(at)) return null;
+  return { at: new Date(at).toISOString(), project: basenameOf(e.cwd), text };
+}
+
+const CODEX_INJECTED = /^\s*(?:<environment_context>|<user_instructions>|<INSTRUCTIONS>|<turn_aborted>|<permissions instructions>|# AGENTS\.md instructions|<user_action>|<skill>)/;
+
+/** One Codex rollout line -> { at, text } or null (project comes from the file's session_meta). */
+export function codexPromptFromLine(line) {
+  let e;
+  try { e = JSON.parse(line); } catch { return null; }
+  const p = e?.payload;
+  if (!p || e.type !== 'event_msg') return null;
+  let raw = null;
+  if (p.type === 'item_completed' && p.item?.type === 'UserMessage') raw = textParts(p.item.content);
+  else if (p.type === 'user_message' && typeof p.message === 'string') raw = p.message;
+  if (raw == null || CODEX_INJECTED.test(raw)) return null;
+  const text = cleanPrompt(raw);
+  const at = Date.parse(e.timestamp);
+  if (!text || !Number.isFinite(at)) return null;
+  return { at: new Date(at).toISOString(), text };
+}
+
+// ---------------------------------------------------------------------------
+// Files
+// ---------------------------------------------------------------------------
+
+function readHead(path, bytes = 65536) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const buf = Buffer.alloc(bytes);
+    const n = readSync(fd, buf, 0, bytes, 0);
+    return buf.subarray(0, n).toString('utf8');
+  } catch { return ''; } finally { if (fd !== undefined) try { closeSync(fd); } catch { /* gone */ } }
+}
+
+/** { cwdBase, subagent } from a Codex file's session_meta (first line). */
+function codexMeta(path) {
+  const first = readHead(path).split('\n', 1)[0];
+  try {
+    const p = JSON.parse(first).payload || {};
+    const src = typeof p.source === 'string' ? p.source : JSON.stringify(p.source || '');
+    return { project: basenameOf(p.cwd), subagent: p.thread_source === 'subagent' || /subagent/.test(src) };
+  } catch { return { project: '', subagent: false }; }
+}
+
+/** Main-session transcripts only: ~/.claude/projects/<dir>/*.jsonl and <codex>/sessions/**\/*.jsonl. */
+export async function discoverPromptFiles({ claudeDir = claudeUserDir(), codexDir = codexUserDir() } = {}) {
+  const out = [];
+  const root = join(claudeDir, 'projects');
+  let dirs = [];
+  try { dirs = readdirSync(root, { withFileTypes: true }); } catch { /* no Claude Code data */ }
+  for (const d of dirs) {
+    if (!d.isDirectory()) continue;
+    let names = [];
+    try { names = readdirSync(join(root, d.name)); } catch { continue; }
+    for (const n of names) if (n.endsWith('.jsonl')) out.push({ path: join(root, d.name, n), source: 'claude' });
+  }
+  try {
+    const sessionsRoot = join(codexDir, 'sessions');
+    for (const f of await discoverCodexSessionFiles({ home: codexDir, days: 36500 })) {
+      if (f.path.startsWith(sessionsRoot)) out.push({ path: f.path, source: 'codex' });
+    }
+  } catch (e) { debug('team-prompts', e); }
+  return out;
+}
+
+const fileKey = (path) => createHash('sha256').update(path).digest('hex').slice(0, 16);
+
+export function loadOffsets(dir = userDataDir()) {
+  try {
+    const o = JSON.parse(readFileSync(promptOffsetsPath(dir), 'utf8'));
+    return o && typeof o === 'object' && !Array.isArray(o) ? o : null;
+  } catch { return null; }
+}
+const saveOffsets = (o, dir) => writeStateFile(promptOffsetsPath(dir), JSON.stringify(o) + '\n');
+export function dropOffsets(dir = userDataDir()) {
+  try { rmSync(promptOffsetsPath(dir), { force: true }); } catch (e) { debug('team-prompts', e); }
+}
+
+function statOf(path) {
+  try { const s = statSync(path); return { size: s.size, ino: s.ino }; } catch { return null; }
+}
+
+/** First sight of capture = on: pin every existing file at its current size. */
+function initOffsets(files, dir) {
+  const o = {};
+  for (const f of files) {
+    const s = statOf(f.path);
+    if (s) o[f.path] = { offset: s.size, size: s.size, ino: s.ino };
+  }
+  saveOffsets(o, dir);
+  return o;
+}
+
+/**
+ * Read one file from its stored offset to the last complete newline and cut the
+ * prompts into chunks. Returns { chunks, end, size, ino } where end is the byte
+ * offset just after the last complete line read. chunk = { start, end, prompts }.
+ */
+function scanFile(file, entry, { maxPrompts, maxBytes }) {
+  const s = statOf(file.path);
+  if (!s) return null;
+  let offset = entry ? entry.offset : 0;
+  if (entry && (s.size < entry.offset || (entry.ino && s.ino && entry.ino !== s.ino))) offset = 0; // shrank or rotated
+  if (s.size <= offset) return { chunks: [], end: offset, size: s.size, ino: s.ino };
+  let fd;
+  try {
+    fd = openSync(file.path, 'r');
+    let win = Math.min(s.size - offset, READ_WINDOW);
+    let buf; let last = -1;
+    for (;;) {
+      buf = Buffer.alloc(win);
+      const n = readSync(fd, buf, 0, win, offset);
+      buf = buf.subarray(0, n);
+      last = buf.lastIndexOf(0x0a);
+      if (last >= 0 || offset + win >= s.size || win >= READ_WINDOW_MAX) break;
+      win = Math.min(win * 2, s.size - offset); // one very long line: widen the window
+    }
+    if (last < 0) return { chunks: [], end: offset, size: s.size, ino: s.ino }; // partial last line: wait
+    const meta = file.source === 'codex' ? codexMeta(file.path) : null;
+    if (meta?.subagent) return { chunks: [], end: offset + last + 1, size: s.size, ino: s.ino };
+    const chunks = [];
+    let cur = { start: offset, end: offset, prompts: [], chars: 0 };
+    let bytes = 0; let total = 0; let pos = 0; let stoppedAt = null;
+    let prevText = null;
+    while (pos <= last) {
+      const nl = buf.indexOf(0x0a, pos);
+      const line = buf.toString('utf8', pos, nl);
+      const lineStart = offset + pos;
+      const lineEnd = offset + nl + 1;
+      let pr = null;
+      if (line.length > 2) pr = file.source === 'codex' ? codexPromptFromLine(line) : claudePromptFromLine(line);
+      if (pr) {
+        if (file.source === 'codex') {
+          pr.project = meta.project;
+          // current rollouts carry both UserMessage and a legacy user_message for one turn
+          if (prevText === pr.text) { pos = nl + 1; cur.end = lineEnd; continue; }
+          prevText = pr.text;
+        }
+        const b = Buffer.byteLength(pr.text);
+        if (total >= maxPrompts || bytes + b > maxBytes) { stoppedAt = lineStart; break; }
+        if (cur.prompts.length >= MAX_CHUNK_PROMPTS || cur.chars + pr.text.length > MAX_CHUNK_CHARS) {
+          cur.end = lineStart;
+          chunks.push(cur);
+          cur = { start: lineStart, end: lineStart, prompts: [], chars: 0 };
+        }
+        cur.prompts.push(pr);
+        cur.chars += pr.text.length;
+        bytes += b; total += 1;
+      }
+      cur.end = lineEnd;
+      pos = nl + 1;
+    }
+    if (stoppedAt !== null) cur.end = stoppedAt;
+    if (cur.prompts.length) chunks.push(cur);
+    const end = stoppedAt !== null ? stoppedAt : offset + last + 1;
+    return { chunks, end, size: s.size, ino: s.ino, stopped: stoppedAt !== null };
+  } catch (e) {
+    debug('team-prompts', e);
+    return null;
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch { /* gone */ }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Upload
+// ---------------------------------------------------------------------------
+
+/**
+ * Upload what is new. `put(params)` calls the prompt_chunk_put RPC and returns its JSON.
+ * Returns { uploaded, chunks, duplicates, capped, off?, error? }.
+ */
+export async function uploadPrompts({
+  put, dir = userDataDir(), claudeDir, codexDir,
+  maxPrompts = MAX_RUN_PROMPTS, maxBytes = MAX_RUN_BYTES,
+} = {}) {
+  const files = await discoverPromptFiles({ claudeDir, codexDir });
+  let offsets = loadOffsets(dir);
+  if (!offsets) {
+    initOffsets(files, dir); // consent boundary: no backfill
+    return { uploaded: 0, chunks: 0, duplicates: 0, capped: false, initialized: true };
+  }
+  const res = { uploaded: 0, chunks: 0, duplicates: 0, capped: false };
+  let promptsLeft = maxPrompts; let bytesLeft = maxBytes;
+  const withMtime = files.map((f) => ({ ...f, mtime: (() => { try { return statSync(f.path).mtimeMs; } catch { return 0; } })() }))
+    .sort((a, b) => a.mtime - b.mtime);
+  for (const f of withMtime) {
+    if (promptsLeft <= 0 || bytesLeft <= 0) { res.capped = true; break; }
+    const entry = offsets[f.path];
+    const scan = scanFile(f, entry, { maxPrompts: promptsLeft, maxBytes: bytesLeft });
+    if (!scan) continue;
+    const restart = entry && (scan.size < entry.offset || (entry.ino && scan.ino && entry.ino !== scan.ino));
+    if (restart) { offsets[f.path] = { offset: 0, size: scan.size, ino: scan.ino }; }
+    const key = fileKey(f.path);
+    for (const c of scan.chunks) {
+      let r;
+      try {
+        r = await put({
+          source: f.source, file_key: key, start_offset: c.start, end_offset: c.end,
+          prompts: c.prompts.map((p) => ({ at: p.at, project: p.project, text: p.text })),
+        });
+      } catch (e) {
+        if (/prompt capture is off/.test(String(e.message))) { res.off = true; return res; }
+        debug('team-prompts', e);
+        res.error = e.message;
+        saveOffsets(offsets, dir);
+        return res;
+      }
+      const accepted = Number(r?.accepted) || 0;
+      if (r?.duplicate) res.duplicates += 1;
+      res.uploaded += accepted;
+      res.chunks += 1;
+      promptsLeft -= c.prompts.length;
+      bytesLeft -= Buffer.byteLength(c.prompts.map((p) => p.text).join(''));
+      offsets[f.path] = { offset: c.end, size: scan.size, ino: scan.ino };
+      saveOffsets(offsets, dir);
+    }
+    // lines after the last prompt carry nothing to send: move past them without a server call
+    if (scan.end > (offsets[f.path]?.offset ?? 0)) {
+      offsets[f.path] = { offset: scan.end, size: scan.size, ino: scan.ino };
+      saveOffsets(offsets, dir);
+    }
+    if (scan.stopped || promptsLeft <= 0 || bytesLeft <= 0) res.capped = true;
+  }
+  return res;
+}
+
+/** For `sprag team status --show-payload`: how many prompts wait and the shape of one (never all the text). */
+export async function pendingPrompts({ dir = userDataDir(), claudeDir, codexDir } = {}) {
+  const offsets = loadOffsets(dir);
+  if (!offsets) return { count: 0, example: null, initialized: false };
+  const files = await discoverPromptFiles({ claudeDir, codexDir });
+  let count = 0; let example = null;
+  for (const f of files) {
+    const scan = scanFile(f, offsets[f.path], { maxPrompts: Infinity, maxBytes: Infinity });
+    if (!scan) continue;
+    for (const c of scan.chunks) {
+      count += c.prompts.length;
+      if (!example && c.prompts.length) {
+        const p = c.prompts[0];
+        example = { at: p.at, project: p.project, text: p.text.slice(0, 80) };
+      }
+    }
+  }
+  return { count, example, initialized: true };
+}
+
+export const promptOffsetsExist = (dir = userDataDir()) => existsSync(promptOffsetsPath(dir));