flowviant 0.115.0 → 0.117.0

package/bin/lib/runtimeLimits.mjs

@@ -40,12 +40,14 @@
  */
 
 import { readdir, open, stat } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { isoFromStamp } from './isoStamp.mjs';
 import { claudeAuthContext } from './claudeAuth.mjs';
 import { detectRuntimes } from './runtimeDetection.mjs';
-import { CODEX_THREAD_RE } from './workSessionRuntime.mjs';
+// Both from leaves (audit 2026-10-10, F126): this machine report sits on
+// runTurn's import path, below the work lanes, and imports none of them.
+import { CODEX_THREAD_RE } from './conversationIds.mjs';
+import { codexHome } from './codexHome.mjs';
 
 /** Claude's `utilization` is a fraction (0.03 = 3%) — MEASURED, see above. */
 export const CLAUDE_UTILIZATION_SCALE = 100;
@@ -254,7 +256,7 @@ export async function learnCodexLimits(threadId, { env = process.env, now } = {}
 export async function codexRolloutFile(threadId, { env = process.env } = {}) {
   try {
     if (typeof threadId !== 'string' || !CODEX_THREAD_RE.test(threadId)) return null;
-    const root = join(env.CODEX_HOME || join(homedir(), '.codex'), 'sessions');
+    const root = join(codexHome(env), 'sessions');
     const key = `${root}\0${threadId}`;
     let file = rolloutPaths.get(key) ?? null;
     if (file) {
@@ -294,9 +296,6 @@ export function claudePlanReading(now = Date.now()) {
   planMemo = { plan, readAt: now };
   return planMemo;
 }
-export function claudePlan() {
-  return claudePlanReading().plan;
-}
 
 const windowOrder = (a, b) =>
   (a.minutes ?? Infinity) - (b.minutes ?? Infinity) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);

package/bin/lib/runtimeOfferings.mjs

@@ -1,26 +1,37 @@
 /** Local, bounded Codex readouts. No agent turn is started for these reports. */
 import { execFileSync } from 'node:child_process';
 import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { readBaseTools } from './projectTools.mjs';
 import { mcpRefusal } from './projectToolRuntimes.mjs';
+import { CODEX_MCP_NAME, normalizeMcpReport } from './runtimeCapabilities.mjs';
+import { unattendedEnv } from './noWindowEnv.mjs';
+import { codexHome } from './codexHome.mjs';
 
 const TTL = 5 * 60_000;
 let cachedAt = 0;
 let cached = null;
 let repoCached = null;
-const home = (env) => env.CODEX_HOME || join(homedir(), '.codex');
 const nameOk = (name) => typeof name === 'string' && /^[A-Za-z0-9_.:-]{1,80}$/.test(name) && name !== 'flowviant';
+// An unattended CLI child like any other (noWindowEnv.mjs, 2026-10-10): `codex
+// mcp list` may start the person's configured servers, and none of them is
+// handed the machine credential or a display.
 const run = (args, env) => execFileSync('codex', args, {
   encoding: 'utf8', timeout: 5000, maxBuffer: 128 * 1024,
-  stdio: ['ignore', 'pipe', 'ignore'], env,
+  stdio: ['ignore', 'pipe', 'ignore'], env: unattendedEnv(env),
 });
+/**
+ * THE `rtp.codex` REPORT, IN THE ONE SHAPE (runtimeCapabilities.mjs
+ * `normalizeMcpReport`, 2026-10-10): the server's charset, names clipped to
+ * its 60 rather than dropped past 80, sorted, at most its 40 — before, names
+ * of 61–80 characters and rows 41–80 were cut silently at the boundary.
+ */
+const codexMcpReport = (entries) => normalizeMcpReport(entries, { charset: CODEX_MCP_NAME });
 
 export function localCodexOfferings({ env = process.env, runCodex = run, read = readFileSync, list = readdirSync } = {}) {
   const result = {};
   try {
-    const cachePath = join(home(env), 'models_cache.json');
+    const cachePath = join(codexHome(env), 'models_cache.json');
     if (read === readFileSync && statSync(cachePath).size > 2 * 1024 * 1024) throw Error('model cache too large');
     const data = JSON.parse(read(cachePath, 'utf8'));
     if (Array.isArray(data.models)) result.models = data.models
@@ -35,18 +46,17 @@ export function localCodexOfferings({ env = process.env, runCodex = run, read =
     result.capabilities = lines.some((line) => /^image_generation\s+\S+\s+true\s*$/.test(line)) ? ['image'] : [];
   } catch { /* a failed local probe is unknown */ }
   try {
-    result.skills = list(join(home(env), 'skills'), { withFileTypes: true })
+    result.skills = list(join(codexHome(env), 'skills'), { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && nameOk(entry.name))
       .map((entry) => entry.name).slice(0, 80);
   } catch (error) { if (error?.code === 'ENOENT') result.skills = []; }
   try {
     const servers = JSON.parse(runCodex(['mcp', 'list', '--json'], env));
-    if (Array.isArray(servers)) result.mcp = servers
+    if (Array.isArray(servers)) result.mcp = codexMcpReport(servers
       // Unknown/unsupported auth is not proof of disconnection. Keep their
       // names local, just as connected servers stay local.
-      .filter((s) => nameOk(s?.name) && ['needs_auth', 'failed'].includes(s.auth_status))
-      .slice(0, 80)
-      .map((s) => ({ n: s.name, s: s.auth_status === 'needs_auth' ? 'needs-auth' : 'failed' }));
+      .filter((s) => typeof s?.name === 'string' && ['needs_auth', 'failed'].includes(s.auth_status))
+      .map((s) => ({ name: s.name, status: s.auth_status === 'needs_auth' ? 'needs-auth' : 'failed' })));
   } catch { /* no read is unknown */ }
   return result;
 }
@@ -68,11 +78,14 @@ export function runtimeOfferings(repoRoot, baseRef, { refresh = false } = {}) {
     }
     const snapshot = repoCached.snapshot;
     if (out.rts.codex) out.rts.codex = [...new Set([...out.rts.codex, ...snapshot.skills.map((s) => s.path.split('/')[2])])].slice(0, 80);
-    if (out.rtp.codex) out.rtp.codex = [...new Map([...out.rtp.codex, ...snapshot.tools
+    // The repo's rows FIRST: a name both report reads as the repo's word, as
+    // the merge it replaced kept (its last write won).
+    if (out.rtp.codex) out.rtp.codex = codexMcpReport([...snapshot.tools
       // A repo server Codex refuses (projectToolRuntimes.mjs owns which) is
       // one this machine cannot connect for Codex, like a broken one.
       .filter((t) => t.state !== 'ready' || mcpRefusal('codex', t.config) != null)
-      .map((t) => ({ n: t.name, s: 'failed' }))].map((server) => [server.n, server])).values()].slice(0, 80);
+      .map((t) => ({ name: t.name, status: 'failed' })),
+    ...out.rtp.codex.map((r) => ({ name: r.n, status: r.s }))]);
   } catch { /* keep local measurements */ }
   return out;
 }

package/bin/lib/runtimes.mjs

@@ -101,6 +101,16 @@ export const RUNTIMES = {
  */
 export const runtimeById = (id) => (typeof id === 'string' && Object.hasOwn(RUNTIMES, id) ? RUNTIMES[id] : null);
 
+/**
+ * The name a sentence uses for a runtime id: its label when this daemon
+ * declares it, else the id as given — an unknown id is relayed, never renamed.
+ * Through `runtimeById`, so an id off the wire or a marker file that happens
+ * to name a prototype key (`constructor`, `__proto__`) reads as the unknown
+ * string it is (audit 2026-10-10, F125). Every lookup of a runtime by id goes
+ * through these two; the registry is subscripted nowhere else.
+ */
+export const runtimeLabel = (id) => runtimeById(id)?.label ?? String(id);
+
 /**
  * Can the worker this daemon is running actually DRIVE this runtime right now?
  *

package/bin/lib/shipSweep.mjs

@@ -1,4 +1,4 @@
-import { baseBranchName } from './git.mjs';
+import { baseBranchName, isSafePathSegment, sessionBranch } from './git.mjs';
 
 /**
  * RETIRE A BRANCH FLOWVIANT MADE AND FLOWVIANT MERGED.
@@ -40,10 +40,12 @@ import { baseBranchName } from './git.mjs';
  * nothing to clean on a remote.
  */
 export function sweepMergedBranch(sessionId, { git, repoRoot, baseRef, note, isReportPending }) {
-  if (!/^[A-Za-z0-9_-]{1,128}$/.test(String(sessionId ?? ''))) return false;
+  // The NAME is git.mjs's one definition, behind the same segment rule every
+  // place passes (audit 2026-10-10, F122) — not a second spelling of either.
+  if (!isSafePathSegment(sessionId)) return false;
   // The report has not landed. See ORDERING above.
   if (isReportPending?.(sessionId)) return false;
-  const name = `session/${sessionId}`;
+  const name = sessionBranch(sessionId);
   try {
     git(['rev-parse', '--verify', '--quiet', `refs/heads/${name}`], repoRoot);
   } catch {

package/bin/lib/shot.mjs

@@ -20,12 +20,25 @@
  *   - A bare VM with no browser AND no system libs: probing/render fails →
  *     graceful text-evidence fallback with an `apt install chromium` hint.
  *   - FLOWVIANT_CHROME / CHROME_PATH override wins over all discovery.
+ *
+ * THE SANDBOX STAYS ON, AND CHROME NEVER HOLDS THE MACHINE CREDENTIAL
+ * (audit 2026-10-10, F081/F135). Every page this file opens is one somebody
+ * else wrote: a design artifact the model authored from a member's card, or
+ * the URL an agent passed to `flowviant shot`. `--no-sandbox` used to ride
+ * every launch "because root and some VMs need it", which turned any renderer
+ * bug into code execution as the operator. It is now passed only where it is
+ * needed: as root (Chrome refuses to start sandboxed there),
+ * `FLOWVIANT_CHROME_NO_SANDBOX=1` (the operator's own call for a box whose
+ * sandbox cannot start), or ONE retry after a launch whose own stderr says the
+ * sandbox could not start — a measured failure, never a guess. The browser's
+ * environment is the daemon's minus the machine credential (`machineEnv.mjs`).
  */
 
 import { spawn, execFileSync } from 'node:child_process';
 import { existsSync, statSync, readFileSync, mkdtempSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir, platform } from 'node:os';
+import { withoutMachineCredentials } from './machineEnv.mjs';
 
 // ── Browser discovery ───────────────────────────────────────────────────────
 
@@ -99,13 +112,51 @@ export function resolveBrowser() {
   return null;
 }
 
+// ── Launch policy ─────────────────────────────────────────────────────────
+
+/** The operator's opt-out for a box whose sandbox cannot start (a container
+ *  without user namespaces). Exactly '1'; anything else keeps it on. */
+export const NO_SANDBOX_ENV = 'FLOWVIANT_CHROME_NO_SANDBOX';
+
+/** Chrome's own words when its sandbox cannot start: the zygote's "No usable
+ *  sandbox!", the setuid helper's complaint, the root refusal, and a namespace
+ *  the kernel would not grant. Only a launch that FAILED is read for these. */
+export const SANDBOX_FAILURE_RE =
+  /No usable sandbox|SUID sandbox helper|without --no-sandbox|Failed to move to new namespace/i;
+
+/** True when Chrome must start without its sandbox before anything is
+ *  measured: as root (Chrome refuses to start sandboxed), or on the operator's
+ *  explicit `FLOWVIANT_CHROME_NO_SANDBOX=1`. */
+export function sandboxOff({ uid = process.getuid?.(), env = process.env } = {}) {
+  return uid === 0 || env?.[NO_SANDBOX_ENV] === '1';
+}
+
+/** The environment every Chrome this daemon starts runs in. */
+export const chromeEnv = (env = process.env) => withoutMachineCredentials(env);
+
+/** The flags every launch shares. `--no-sandbox` only when `noSandbox`. */
+export function chromeFlags({ headlessFlag, noSandbox, userDataDir, width, height }) {
+  return [
+    headlessFlag,
+    '--disable-gpu',
+    ...(noSandbox ? ['--no-sandbox'] : []),
+    '--disable-dev-shm-usage', // small /dev/shm in containers/VMs crashes Chrome otherwise
+    '--hide-scrollbars',
+    '--force-color-profile=srgb',
+    '--no-first-run',
+    '--disable-extensions',
+    `--user-data-dir=${userDataDir}`,
+    `--window-size=${width},${height}`,
+  ];
+}
+
 // ── Capture ─────────────────────────────────────────────────────────────────
 
 function toWinPath(p) {
   return execFileSync('wslpath', ['-w', p], { encoding: 'utf8' }).trim();
 }
 
-function runChrome(browser, { url, out, width, height, headlessFlag, timeoutMs }) {
+function runChrome(browser, { url, out, width, height, headlessFlag, timeoutMs, noSandbox }, { spawnImpl, env }) {
   return new Promise((resolve) => {
     const userDataDir = mkdtempSync(join(tmpdir(), 'flowviant-shot-'));
     const cleanup = () => { try { rmSync(userDataDir, { recursive: true, force: true }); } catch { /* best effort */ } };
@@ -124,14 +175,7 @@ function runChrome(browser, { url, out, width, height, headlessFlag, timeoutMs }
     }
 
     const args = [
-      headlessFlag,
-      '--disable-gpu',
-      '--no-sandbox',            // required as root / in many VMs + containers
-      '--disable-dev-shm-usage', // small /dev/shm in containers/VMs crashes Chrome otherwise
-      '--hide-scrollbars',
-      '--force-color-profile=srgb',
-      `--user-data-dir=${udArg}`,
-      `--window-size=${width},${height}`,
+      ...chromeFlags({ headlessFlag, noSandbox, userDataDir: udArg, width, height }),
       '--virtual-time-budget=5000', // let fonts/JS settle before capture (SPAs)
       `--screenshot=${outArg}`,
       url,
@@ -140,7 +184,7 @@ function runChrome(browser, { url, out, width, height, headlessFlag, timeoutMs }
     let err = '';
     let child;
     try {
-      child = spawn(browser.bin, args, { stdio: ['ignore', 'ignore', 'pipe'] });
+      child = spawnImpl(browser.bin, args, { stdio: ['ignore', 'ignore', 'pipe'], env: chromeEnv(env) });
     } catch (e) {
       cleanup();
       return resolve({ ok: false, reason: 'spawn', message: e.message });
@@ -157,15 +201,34 @@ function runChrome(browser, { url, out, width, height, headlessFlag, timeoutMs }
       cleanup();
       if (existsSync(out) && statSync(out).size > 0) return resolve({ ok: true, path: out });
       const tail = err.trim().split('\n').slice(-2).join(' ');
-      resolve({ ok: false, reason: 'render', message: `Chrome exited (code ${code}) without an image.${tail ? ' ' + tail : ''}` });
+      resolve({
+        ok: false,
+        reason: 'render',
+        message: `Chrome exited (code ${code}) without an image.${tail ? ' ' + tail : ''}`,
+        sandboxFailed: !noSandbox && SANDBOX_FAILURE_RE.test(err),
+      });
     });
   });
 }
 
 /** Capture `url` to a PNG at `out`. Tries new headless, then classic headless
- *  (older Chromium). Resolves { ok, path } or { ok:false, reason, message }. */
-export async function captureScreenshot({ url, out, width = 1440, height = 900, timeoutMs = 60_000 }) {
-  const browser = resolveBrowser();
+ *  (older Chromium), sandboxed unless `sandboxOff` — and at most ONE launch
+ *  without it, after a sandboxed launch that said its sandbox could not start.
+ *  Resolves { ok, path } or { ok:false, reason, message }.
+ *
+ *  `browser`, `spawn`, `uid` and `env` are injectable so the launch policy is
+ *  provable without a browser; nothing in the daemon passes them. */
+export async function captureScreenshot({
+  url,
+  out,
+  width = 1440,
+  height = 900,
+  timeoutMs = 60_000,
+  browser = resolveBrowser(),
+  spawn: spawnImpl = spawn,
+  uid = process.getuid?.(),
+  env = process.env,
+}) {
   if (!browser) {
     return {
       ok: false,
@@ -173,12 +236,23 @@ export async function captureScreenshot({ url, out, width = 1440, height = 900,
       message: 'No Chrome/Chromium/Edge found. Install one (Linux: `sudo apt install chromium`) to capture screenshot evidence.',
     };
   }
-  let r = await runChrome(browser, { url, out, width, height, headlessFlag: '--headless=new', timeoutMs });
+  let noSandbox = sandboxOff({ uid, env });
+  const attempt = async (headlessFlag) => {
+    const run = () => runChrome(browser, { url, out, width, height, headlessFlag, timeoutMs, noSandbox }, { spawnImpl, env });
+    let r = await run();
+    if (!r.ok && r.sandboxFailed) {
+      noSandbox = true; // sticky: the one retry this capture gets
+      r = await run();
+    }
+    return r;
+  };
+  let r = await attempt('--headless=new');
   if (!r.ok && r.reason === 'render') {
     // Older Chromium rejects `--headless=new` — retry with classic headless.
-    r = await runChrome(browser, { url, out, width, height, headlessFlag: '--headless', timeoutMs });
+    r = await attempt('--headless');
   }
-  return r;
+  const { sandboxFailed: _measured, ...result } = r;
+  return result;
 }
 
 // ── CLI ───────────────────────────────────────────────────────────────────

package/bin/lib/sleep.mjs

@@ -0,0 +1,11 @@
+/**
+ * WAIT N SECONDS — a leaf with no imports (2026-10-10, the audit).
+ *
+ * It lived in claude.mjs, the module that hands a coding CLI its MCP server,
+ * which imports the runtime registry (runtimes.mjs) and through it every
+ * vendor's adapter. So `flowviant login`, the one command that has to work on
+ * a fresh box, loaded every runtime module just to wait between two polls, and
+ * a fault importing any of them could break it. login.mjs, fleet.mjs and
+ * holder.mjs import it from here; nothing here may import anything.
+ */
+export const sleep = (s) => new Promise((r) => setTimeout(r, s * 1000));

package/bin/lib/startProject.mjs

@@ -17,18 +17,18 @@
  */
 import { FLEET_TOKEN, CREDENTIAL, adoptStoredCredential } from './config.mjs';
 import { runLogin } from './login.mjs';
-import { terminalCommand } from './launchCommand.mjs';
+import { relaunchSelf, selfArgv, terminalCommand } from './launchCommand.mjs';
 import { canPrompt, askWithTimeout, selectMenu, menuSupported } from './tty.mjs';
 
 /** Re-exec a plain `flowviant` after an inline login — the login command's own
  *  pattern: config.mjs read the store at IMPORT time, before the credential
- *  existed, so this process cannot serve; the child can. */
+ *  existed, so this process cannot serve; the child can. Through the one
+ *  relaunch proxy (launchCommand.mjs), which passes signals on and reads a
+ *  child killed by one as a failure. */
 async function reexecAfterLogin() {
   const login = await runLogin({ thenStart: false });
   if (!login?.saved) process.exit(1); // refused: the directory already serves another project
-  const { spawn } = await import('node:child_process');
-  const child = spawn(process.execPath, process.argv[1]?.startsWith('/$bunfs/') ? [] : [process.argv[1]], { stdio: 'inherit', env: process.env });
-  process.exit(await new Promise((resolve) => child.on('exit', (code) => resolve(code ?? 0))));
+  await relaunchSelf({ argv: selfArgv(), env: process.env });
 }
 
 // TWO ROWS THAT READ ALIKE ARE NOT A CHOICE. `projectRowLabel` adds the id and

package/bin/lib/statePaths.mjs

@@ -0,0 +1,40 @@
+/**
+ * WHERE THE DAEMON KEEPS A CHECKOUT'S WORKTREES — one derivation (audit
+ * 2026-10-10, F075).
+ *
+ * The per-checkout worktree home, `~/.flowviant/worktrees/<basename>-<8 hex
+ * of sha256(repoRoot)>`, was written twice — fleetStartup.worktreeHome and
+ * deployCheckout's fallback — and its parent a third time in `flowviant
+ * clean`. Two copies of a key can drift silently, and a drift here is a
+ * deploy checkout landing somewhere the startup reap and the machine's disk
+ * line never look, while `clean` still sweeps the parent. So every reader
+ * asks this leaf.
+ *
+ * A LEAF: node built-ins only, so a command that must stay light (`clean`)
+ * can import it without the daemon's config. Nothing here makes a directory —
+ * the caller that needs one (worktreeHome) makes it. `homedir()` is read AT
+ * CALL TIME, so a test (or anything else) that sets HOME after import is
+ * heard.
+ *
+ * THE KEY IS NOT TO BE CHANGED casually: a different key strands every
+ * persisted worktree and deploy scratch under the old one, outside the reap.
+ */
+
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+
+/** `~/.flowviant/worktrees` — the parent of every checkout's worktree home. */
+export function worktreesRoot() {
+  return join(homedir(), '.flowviant', 'worktrees');
+}
+
+/** `<basename>-<first 8 hex of sha256(repoRoot)>` — the checkout's key. */
+export function worktreeHomeKey(repoRoot) {
+  return `${basename(repoRoot)}-${createHash('sha256').update(repoRoot).digest('hex').slice(0, 8)}`;
+}
+
+/** The checkout's worktree home, NOT created. */
+export function worktreeHomeDir(repoRoot) {
+  return join(worktreesRoot(), worktreeHomeKey(repoRoot));
+}

package/bin/lib/tty.mjs

@@ -44,16 +44,20 @@
  * they are what keeps a backgrounded job from freezing.
  */
 
-import { readFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
+import { procStat } from './procStat.mjs';
 
 /**
- * Is this process in the controlling terminal's foreground process group?
+ * WHERE THIS PROCESS STANDS ON ITS TERMINAL: `true` measured in the
+ * controlling terminal's foreground process group, `false` measured in the
+ * background, `null` when there is no controlling terminal or it could not be
+ * read. `inForeground` folds the two non-answers into "foreground"; the
+ * relaunch proxy (launchCommand.mjs) needs them apart.
  *
  * Linux: BOTH numbers come out of one `/proc/self/stat` read — field 5 is our
  * own `pgrp` and field 8 is `tpgid`, the foreground group of our controlling
- * terminal. Parsed from AFTER the last ')' because field 2 is the executable
- * name and may itself contain spaces and parentheses.
+ * terminal — through procStat.mjs, because field 2 is the executable name and
+ * may itself contain spaces and parentheses.
  *
  * NOT `process.getpgrp()`: it DOES NOT EXIST in Node (verified on 24.16 — it
  * throws `TypeError: process.getpgrp is not a function`). The first cut of this
@@ -64,18 +68,15 @@ import { execFileSync } from 'node:child_process';
  * isolation on a real pty; nothing else would have shown it, because the
  * fallback it degraded to still behaves acceptably.
  *
- * Elsewhere: ask `ps` for both. Unknown: assume foreground (see the header).
+ * Elsewhere: ask `ps` for both.
  */
-export function inForeground() {
+export function terminalForeground() {
   try {
     if (process.platform === 'linux') {
-      const stat = readFileSync('/proc/self/stat', 'utf8');
-      const after = stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/);
-      const pgrp = Number(after[2]); // state ppid PGRP session tty_nr tpgid
-      const tpgid = Number(after[5]);
-      if (!Number.isFinite(tpgid) || !Number.isFinite(pgrp)) return true;
-      if (tpgid <= 0) return true; // no controlling terminal — nothing to be behind
-      return tpgid === pgrp;
+      const stat = procStat('self');
+      if (!stat) return null;
+      if (stat.tpgid <= 0) return null; // no controlling terminal — nothing to be behind
+      return stat.tpgid === stat.pgrp;
     }
     const out = execFileSync('ps', ['-o', 'tpgid=,pgid=', '-p', String(process.pid)], {
       encoding: 'utf8',
@@ -84,13 +85,22 @@ export function inForeground() {
     }).trim().split(/\s+/);
     const tpgid = Number(out[0]);
     const pgrp = Number(out[1]);
-    if (!Number.isFinite(tpgid) || !Number.isFinite(pgrp) || tpgid <= 0) return true;
+    if (!Number.isFinite(tpgid) || !Number.isFinite(pgrp) || tpgid <= 0) return null;
     return tpgid === pgrp;
   } catch {
-    return true;
+    return null;
   }
 }
 
+/**
+ * Is this process in the controlling terminal's foreground process group?
+ * No controlling terminal has nothing to be behind, and unknown assumes
+ * foreground (see the header): only a MEASURED background answers false.
+ */
+export function inForeground() {
+  return terminalForeground() !== false;
+}
+
 /** A human is at this terminal AND can actually be reached by a question. */
 export function canPrompt() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY) && inForeground();

package/bin/lib/turnLock.mjs

@@ -10,7 +10,7 @@
  * means is this module's.
  */
 import { existsSync, readFileSync, rmSync } from 'node:fs';
-import { processStartTime } from './procRegistry.mjs';
+import { aliveAndOurs, processStartTime } from './procRegistry.mjs';
 
 /**
  * The spawn lock: the pid of the CLI currently live in this worktree. A
@@ -45,19 +45,12 @@ export const turnLockedByLivePid = (lockPath) => {
   } catch {
     /* unreadable — treat as stale */
   }
-  if (Number.isInteger(pid) && pid > 0) {
-    let alive = false;
-    try {
-      process.kill(pid, 0);
-      alive = true; // signal 0 delivered — a process of OUR uid holds the pid
-    } catch {
-      /* ESRCH: gone. EPERM: another uid's process — never our CLI. Stale. */
-    }
-    if (alive) {
-      const now = start ? processStartTime(pid) : null;
-      // Unmeasurable start time is "cannot tell", which keeps the lock.
-      if (!start || !now || now === start) return true;
-    }
+  // Signal 0 delivered to a process of OUR uid; EPERM is another uid's process,
+  // never our CLI, so stale (procRegistry.aliveAndOurs).
+  if (aliveAndOurs(pid)) {
+    const now = start ? processStartTime(pid) : null;
+    // Unmeasurable start time is "cannot tell", which keeps the lock.
+    if (!start || !now || now === start) return true;
   }
   try {
     rmSync(lockPath, { force: true }); // dead holder — clear the stale lock

package/bin/lib/turnProfile.mjs

@@ -22,7 +22,7 @@
  *  - design / research / image — a non-code card's posture
  *                (agentTaskKinds.mjs), refused on any runtime that does not
  *                DECLARE it, because every other adapter's fallback is its
- *                build branch. research is Claude Code's; design is
+ *                build branch. research is Claude Code's and isolated Codex's; design is
  *                Claude Code's and, since 0.115.0, Codex's; image (0.114.0)
  *                is Codex's.
  *

package/bin/lib/ui.mjs

@@ -9,9 +9,6 @@ export const c = {
   blue: wrap(34), magenta: wrap(35), cyan: wrap(36), gray: wrap(90),
 };
 
-// Stable, cycled colours so each agent's label is easy to scan in a fleet.
-export const LABEL_COLORS = [c.cyan, c.magenta, c.blue, c.yellow, c.green, c.red];
-
 const stamp = () => {
   const d = new Date();
   const p = (n) => String(n).padStart(2, '0');

package/bin/lib/uninstall.mjs

@@ -3,7 +3,9 @@ import { execFile as nodeExecFile } from 'node:child_process';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
-import { runningCompiledBinary } from './update.mjs';
+import { runningCompiledBinary } from './launchCommand.mjs';
+import { listDaemonLocks } from './daemonLocks.mjs';
+import { processAlive } from './procRegistry.mjs';
 import { VERSION } from './config.mjs';
 import { parseVersion } from './versionOrder.mjs';
 import { copyKind, exactBlock, inside } from './uninstallCopies.mjs';
@@ -18,7 +20,9 @@ function defaults(options = {}) {
     home: homedir(),
     path: process.env.PATH || '',
     execFile: (file, args, opts) => execFileAsync(file, args, opts),
-    pidLive: (pid) => { try { process.kill(pid, 0); return true; } catch { return false; } },
+    // EPERM is alive (2026-10-10, F090/F123): a conservative alignment with the
+    // one probe — a pid we may not signal still protects the copy it may run.
+    pidLive: processAlive,
     procReader: (pid, file) => file === 'exe' || file === 'cwd'
       ? nodeFs.readlinkSync(`/proc/${pid}/${file}`) : nodeFs.readFileSync(`/proc/${pid}/${file}`),
     procAvailable: nodeFs.existsSync('/proc/self/cmdline'),
@@ -58,32 +62,32 @@ function compiledExecutable(fs, path) {
   } catch { return false; }
 }
 
+// The lock files and their records come from the one scan instance.mjs uses
+// (daemonLocks.mjs), through the injected fs and home; an unreadable lock is
+// not evidence of a live daemon.
 function liveDaemons(o) {
   const found = [];
-  for (const name of files(o.fs, join(o.home, '.flowviant'))) {
-    if (!/^daemon-[0-9a-f]{12}\.lock$/.test(name)) continue;
-    try {
-      const pid = JSON.parse(o.fs.readFileSync(join(o.home, '.flowviant', name), 'utf8')).pid;
-      if (!Number.isInteger(pid) || pid <= 0 || !o.pidLive(pid)) continue;
-      let paths = [];
-      if (o.procAvailable) {
-        try {
-          const exe = o.procReader(pid, 'exe');
-          const command = o.procReader(pid, 'cmdline');
-          const args = Buffer.from(command).toString('utf8').split('\0').filter(Boolean);
-          let scripts = args.filter((arg) => isAbsolute(arg));
-          const relative = args.filter((arg) => !arg.startsWith('-') && arg.includes('/') && !isAbsolute(arg));
-          if (relative.length) {
-            const cwd = String(o.procReader(pid, 'cwd'));
-            scripts.push(...relative.map((arg) => resolve(cwd, arg)));
-          }
-          const executable = String(exe).replace(/ \(deleted\)$/, '');
-          paths = basename(executable).startsWith('node') && !scripts.length ? [] :
-            [executable, ...scripts].map((path) => real(o.fs, path));
-        } catch { /* The live pid is still protected when its command is hidden. */ }
-      }
-      found.push({ pid, paths });
-    } catch { /* An unreadable lock is not evidence of a live daemon. */ }
+  for (const { holder } of listDaemonLocks({ fs: o.fs, home: o.home })) {
+    if (!holder || !o.pidLive(holder.pid)) continue;
+    const pid = holder.pid;
+    let paths = [];
+    if (o.procAvailable) {
+      try {
+        const exe = o.procReader(pid, 'exe');
+        const command = o.procReader(pid, 'cmdline');
+        const args = Buffer.from(command).toString('utf8').split('\0').filter(Boolean);
+        let scripts = args.filter((arg) => isAbsolute(arg));
+        const relative = args.filter((arg) => !arg.startsWith('-') && arg.includes('/') && !isAbsolute(arg));
+        if (relative.length) {
+          const cwd = String(o.procReader(pid, 'cwd'));
+          scripts.push(...relative.map((arg) => resolve(cwd, arg)));
+        }
+        const executable = String(exe).replace(/ \(deleted\)$/, '');
+        paths = basename(executable).startsWith('node') && !scripts.length ? [] :
+          [executable, ...scripts].map((path) => real(o.fs, path));
+      } catch { /* The live pid is still protected when its command is hidden. */ }
+    }
+    found.push({ pid, paths });
   }
   return found;
 }