flowviant 0.116.0 → 0.124.0

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,10 +22,18 @@
  *  - 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.
  *
+ * `projectMcp` (2026-10-10, the owner): whether an agent's turn under this
+ * profile mounts MCP servers — the project's reviewed base `.mcp.json` copy
+ * and, since 2026-10-11 ("the server that is running flowviant's claude HAS
+ * these MCPs yet the agents are not using them"), this machine's own CLI
+ * servers and claude.ai connectors. Every card's posture: the code card's
+ * build, and the write-up's, mockup/3D-model/deck's and image's fences. The
+ * consult, plan, wiki and plan-mode turns are not a card's and mount none.
+ *
  * Claude's permission list for each name lives beside the lists themselves
  * (`claudePermFor`, claudePosture.mjs); this module owns the vocabulary and the
  * refusals, and imports the card-kind table and the runtime registry (whose
@@ -44,10 +52,12 @@ const declaredBy = (name) =>
     .join(' or ') || 'no CLI this daemon knows';
 const article = (word) => (/^[aeiou]/i.test(word) ? 'an' : 'a');
 
-const plain = (adapterProfile) => Object.freeze({ adapterProfile, onlyOn: null, strictMcp: false });
+const plain = (adapterProfile) => Object.freeze({ adapterProfile, onlyOn: null, strictMcp: false, projectMcp: false });
+/** The kind postures that mount MCP servers (2026-10-10; image 2026-10-11). */
+const KIND_PROJECT_MCP = new Set(['design', 'research', 'image']);
 
 export const TURN_PROFILES = Object.freeze({
-  build: plain('build'),
+  build: Object.freeze({ ...plain('build'), projectMcp: true }),
   wiki: plain('wiki'),
   consult: plain('consult'),
   plan: plain('plan'),
@@ -58,6 +68,7 @@ export const TURN_PROFILES = Object.freeze({
     // wearing the word "plan".
     onlyOn: (rt) => (rt.id === 'claude' ? null : `plan mode runs on Claude Code only — not '${rt.label}'`),
     strictMcp: true,
+    projectMcp: false,
   }),
   // The kind postures: fenced to "write only the artifacts directory", and a
   // runtime that does not declare one would run its build branch instead.
@@ -73,6 +84,7 @@ export const TURN_PROFILES = Object.freeze({
             ? null
             : `${article(name)} ${name} card runs on ${declaredBy(name)} only — not '${rt.label}'`,
         strictMcp: false,
+        projectMcp: KIND_PROJECT_MCP.has(name),
       }),
     ])
   ),
@@ -83,7 +95,7 @@ export const TURN_PROFILES = Object.freeze({
 export const RETIRED_POSTURE_KEYS = Object.freeze(['wikiPerm', 'readOnly', 'planPerm', 'planMode', 'posture']);
 
 /**
- * `{ name, adapterProfile, onlyOn, strictMcp }` for a turn's options, or
+ * `{ name, adapterProfile, onlyOn, strictMcp, projectMcp }` for a turn's options, or
  * `{ error }` in words. Absent `profile` is build.
  */
 export function resolveTurnProfile(opts = {}) {

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;
 }

package/bin/lib/update.mjs

@@ -33,11 +33,12 @@ import { execFileSync, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { createReadStream, createWriteStream } from 'node:fs';
 import { chmod, mkdtemp, open, rename, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { platform, arch } from 'node:process';
 import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
-import { runningViaNpx, terminalCommand } from './launchCommand.mjs';
+import { relaunchSelf, runningCompiledBinary, runningViaNpx, selfArgv, terminalCommand } from './launchCommand.mjs';
 import { VERSION } from './config.mjs';
 import { compareVersions, versionBelow } from './versionOrder.mjs';
 import { note, ok, warn } from './ui.mjs';
@@ -48,9 +49,40 @@ import { note, ok, warn } from './ui.mjs';
  * never installs, never restarts and never nags on a version it cannot read.
  */
 
-/** Bun marks compiled entrypoints with a virtual /$bunfs/ script path. */
-export function runningCompiledBinary() {
-  return Boolean(process.versions.bun && process.argv[1]?.startsWith('/$bunfs/'));
+// Channel detection lives in launchCommand.mjs; re-exported for this module's callers.
+export { runningCompiledBinary };
+
+/**
+ * NPM RUNS FROM OUTSIDE THE CHECKOUT (2026-10-10, F131). The daemon's working
+ * directory IS the repository (the person launched there, or `--dir` chdir'd
+ * to it), and npm loads a project's `.npmrc` from the nearest package root —
+ * its `registry=` and `node-options=` included — for `npm exec` and `npm view`.
+ * A change that reached base could then steer the unattended self-update to
+ * another registry or preload code into it, outside any agent posture. From
+ * the home directory npm reads only the operator's own user and global config,
+ * which is honoured as it is: no registry is forced.
+ */
+export function npmOutsideCheckout() {
+  return { cwd: homedir() };
+}
+
+/**
+ * The npx relaunch's argv: the same flags, with the checkout named explicitly
+ * and ABSOLUTELY, because the relaunch no longer starts inside it. Any `--dir`
+ * pair already there is replaced — a relative one would now resolve against
+ * the home directory. `cwd` is this process's, which cli.mjs already moved to
+ * the `--dir` it was given; a bare start honours `--dir` (commandSpecs.mjs).
+ */
+export function npxRelaunchArgs(args = process.argv.slice(2), cwd = process.cwd()) {
+  const kept = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--dir') {
+      i++; // and its value
+      continue;
+    }
+    kept.push(args[i]);
+  }
+  return ['-y', 'flowviant@latest', ...kept, '--dir', cwd];
 }
 
 const RELEASE_ORIGIN = 'https://api.flowviant.com';
@@ -115,9 +147,15 @@ export async function installBinaryUpdate({
  * `npm i -g` overwrote the global package in place, so re-running argv[1] loads
  * the NEW code. We tear down first (idle-gated, so nothing's mid-task) and keep
  * this process alive only as a thin proxy waiting on the child, so the user's
- * shell stays attached to one foreground process.
+ * shell stays attached to one foreground process — the one relaunch proxy
+ * (launchCommand.mjs `relaunchSelf`), which passes signals on and reads a
+ * successor killed by one (the OOM killer) as a failure, so `Restart=on-failure`
+ * relaunches the machine instead of leaving it dark.
+ *
+ * `deps` (spawn, exit, signals) are relaunchSelf's test seams; the daemon
+ * passes none.
  */
-function reexec(teardown, { viaNpx = false, viaBinary = false, target = null } = {}) {
+export function reexec(teardown, { viaNpx = false, target = null } = {}, deps = {}) {
   try {
     teardown?.();
   } catch {
@@ -128,12 +166,16 @@ function reexec(teardown, { viaNpx = false, viaBinary = false, target = null } =
   // to leave, and re-running it would reload the stale copy forever. Going back
   // through `npx -y flowviant@latest` is what makes npx resolve `latest` against
   // the registry and fetch the new one. `-y` because a restart must never stop
-  // on npx's install prompt — the same rule FLOWVIANT_REEXEC keeps below.
-  const [cmd, args] = viaNpx
-    ? ['npx', ['-y', 'flowviant@latest', ...process.argv.slice(2)]]
-    : [process.execPath, process.argv.slice(viaBinary ? 2 : 1)];
-  const child = spawn(cmd, args, {
-    stdio: 'inherit',
+  // on npx's install prompt — the same rule FLOWVIANT_REEXEC keeps below. It
+  // runs from outside the checkout and names it with `--dir` (npmOutsideCheckout).
+  const [cmd, argv, where] = viaNpx
+    ? ['npx', npxRelaunchArgs(), npmOutsideCheckout()]
+    : [process.execPath, selfArgv(process.argv.slice(2)), {}];
+  return relaunchSelf({
+    ...deps,
+    cmd,
+    argv,
+    ...where,
     // MARK THE CHILD AS A RESTART, not as a person typing `flowviant`.
     // stdio is inherited, so the child sees two TTYs and believes a human is
     // watching — and 0.55.0 asks a one-time binding question on exactly that
@@ -163,7 +205,6 @@ function reexec(teardown, { viaNpx = false, viaBinary = false, target = null } =
       FLOWVIANT_UPDATE_FROM: VERSION,
     },
   });
-  child.on('exit', (code) => process.exit(code ?? 0));
 }
 
 /**
@@ -184,7 +225,29 @@ export function updateRestartFailed(target) {
 
 /** Install @latest globally. Throws on failure (EACCES without sudo, offline…). */
 function installLatest() {
-  execFileSync('npm', ['install', '-g', 'flowviant@latest'], { stdio: 'inherit' });
+  execFileSync('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit' });
+}
+
+/**
+ * What npm says `flowviant@latest` is, or null when it cannot say (offline, an
+ * npm hiccup, a hung registry) — read from outside the checkout like every
+ * other npm call here. `exec` is the test seam.
+ */
+export function publishedVersion({ exec = execFileSync } = {}) {
+  try {
+    return String(
+      exec('npm', ['view', 'flowviant', 'version'], {
+        ...npmOutsideCheckout(),
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        // Synchronous, so it holds the event loop hostage for however long it
+        // runs — a hung registry must not become a hung daemon.
+        timeout: 10_000,
+      })
+    ).trim();
+  } catch {
+    return null; // offline / npm hiccup — "can't confirm", skip this poll
+  }
 }
 
 /** `flowviant update` — explicit, manual update. Does not re-exec into a daemon
@@ -289,7 +352,7 @@ export async function handleVersionSignal({ latest, min, autoUpdate, safeToUpdat
       try {
         spawn(process.execPath, ['uninstall', '--others', '--yes', '--json'], { detached: true, stdio: 'ignore' }).unref();
       } catch (e) { warn(`older-copy cleanup: ${e?.message ?? e}`); }
-      reexec(teardown, { viaBinary: true, target: installed });
+      reexec(teardown, { target: installed });
       return true;
     } catch (e) {
       lastInstallFailAt = Date.now();
@@ -339,18 +402,7 @@ export async function handleVersionSignal({ latest, min, autoUpdate, safeToUpdat
     // the source of truth — only install if npm ACTUALLY has something newer than
     // us, else `npm i -g @latest` reinstalls our own version and we'd re-exec
     // forever.
-    let published = null;
-    try {
-      published = execFileSync('npm', ['view', 'flowviant', 'version'], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-        // Synchronous, so it holds the event loop hostage for however long it
-        // runs — a hung registry must not become a hung daemon.
-        timeout: 10_000,
-      }).trim();
-    } catch {
-      /* offline / npm hiccup — treat as "can't confirm", skip this poll */
-    }
+    const published = publishedVersion();
     // An unreadable answer from npm is "can't confirm", like no answer at all.
     const publishedOrder = published ? compareVersions(published, cur) : null;
     if (publishedOrder === null || publishedOrder <= 0) {