flowviant 0.116.0 → 0.124.0

package/bin/lib/pinnedCapture.mjs

@@ -0,0 +1,383 @@
+/**
+ * A SCREENSHOT OF ONE PAGE, AND ONLY THAT PAGE (audit 2026-10-10, F657/F756).
+ *
+ * `captureScreenshot` (shot.mjs) photographs whatever document Chrome ends up
+ * on. For a page somebody else wrote that is the wrong question: the design
+ * preview used to load the model's HTML as a top-level `file://` document,
+ * and a `<meta http-equiv=refresh>` (or `location.replace`) to
+ * `file:///home/<you>/.flowviant/credentials.json` made the uploaded PNG a
+ * picture of every machine credential on the box — past the read fence the
+ * design posture exists for, and past the secret scrub, which reads text, not
+ * pixels. CSP has no working control over top-level navigation.
+ *
+ * This capture drives Chrome over its DevTools pipe (`--remote-debugging-pipe`
+ * — no port, nothing another local process can reach) and holds the page to
+ * the one URL it was given:
+ *
+ *  - EVERY network request is paused. The first Document request for `url` is
+ *    the page and goes through; any other Document request — a meta refresh,
+ *    a script navigation, a frame — is failed AND marks the capture as having
+ *    left the page. Subresources go through only when `allowSubresource` says
+ *    so (the page's own CSP hosts); the rest are failed quietly.
+ *  - A NEW PAGE (window.open, target=_blank) is paused before it runs, closed,
+ *    and marks the capture as having left the page.
+ *  - Downloads are denied.
+ *  - Before the PNG is kept, the committed document must still be `url`
+ *    (fragment aside) and must not be an error page.
+ *
+ * Any of those failing is `{ ok: false, reason: 'left-page' }`, and the caller
+ * (artifactPreview.mjs) reports `renderState: 'unavailable'` with no preview.
+ * Chrome itself refuses a navigation from an http page to `file://`, which is
+ * why the caller serves the page over loopback http rather than from disk.
+ *
+ * A Windows browser reached through WSL interop cannot be driven: interop
+ * bridges stdin/stdout/stderr and nothing else, so the DevTools pipe on fds 3
+ * and 4 never arrives. That path answers 'unavailable' rather than a
+ * screenshot nobody verified.
+ *
+ * The launch obeys shot.mjs's policy: sandboxed unless `sandboxOff`, one retry
+ * without it after a launch that measured a sandbox failure, and the machine
+ * credential stripped from Chrome's environment.
+ */
+
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir, platform } from 'node:os';
+import { SANDBOX_FAILURE_RE, chromeEnv, chromeFlags, resolveBrowser, sandboxOff } from './shot.mjs';
+import { killGroup } from './processGroup.mjs';
+
+/** How long a closing browser gets to exit before it is killed. */
+const EXIT_GRACE_MS = 3_000;
+/** How long the page Chrome just made gets to be auto-attached. */
+const ATTACH_WAIT_MS = 2_000;
+
+/**
+ * A DevTools client over a pipe pair: JSON messages, each ended by a NUL.
+ * `send(method, params, sessionId)` resolves the result or rejects with the
+ * protocol's error; `on(fn)` receives every event; `close(reason)` rejects
+ * whatever is still waiting (the browser is gone).
+ */
+export function createCdpClient(writable, readable) {
+  let nextId = 0;
+  let closed = null;
+  const waiting = new Map();
+  const listeners = [];
+  let chunks = [];
+  readable.on('data', (d) => {
+    let start = 0;
+    for (let i = 0; i < d.length; i++) {
+      if (d[i] !== 0) continue;
+      chunks.push(d.subarray(start, i));
+      start = i + 1;
+      let msg;
+      try {
+        msg = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      } catch {
+        msg = null;
+      }
+      chunks = [];
+      if (!msg) continue;
+      if (msg.id != null && waiting.has(msg.id)) {
+        const w = waiting.get(msg.id);
+        waiting.delete(msg.id);
+        if (msg.error) w.reject(new Error(msg.error.message || 'protocol error'));
+        else w.resolve(msg.result ?? {});
+      } else if (msg.method) {
+        for (const fn of listeners) fn(msg);
+      }
+    }
+    if (start < d.length) chunks.push(d.subarray(start));
+  });
+  return {
+    send(method, params = {}, sessionId) {
+      if (closed) return Promise.reject(new Error(closed));
+      const id = ++nextId;
+      const msg = { id, method, params, ...(sessionId ? { sessionId } : {}) };
+      return new Promise((resolve, reject) => {
+        waiting.set(id, { resolve, reject });
+        try {
+          writable.write(JSON.stringify(msg) + '\0');
+        } catch (e) {
+          waiting.delete(id);
+          reject(e);
+        }
+      });
+    },
+    on(fn) {
+      listeners.push(fn);
+    },
+    close(reason) {
+      if (closed) return;
+      closed = reason;
+      for (const w of waiting.values()) w.reject(new Error(reason));
+      waiting.clear();
+    },
+  };
+}
+
+/** `a` and `b` name the same document: equal once the fragment is dropped. */
+export function sameDocument(a, b) {
+  try {
+    const x = new URL(a);
+    const y = new URL(b);
+    x.hash = '';
+    y.hash = '';
+    return x.href === y.href;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * One launch, one page, one PNG. Resolves `{ ok: true }` with the PNG written
+ * to `out`, or `{ ok: false, reason, message, launchFailed?, sandboxFailed? }`.
+ * `launchFailed` means the browser never answered on the pipe — the only
+ * failure a different launch (classic headless, or no sandbox) can change.
+ */
+async function captureOnce(browser, { url, out, width, height, timeoutMs, budgetMs, allowSubresource, headlessFlag, noSandbox }, { spawnImpl, env }) {
+  const userDataDir = mkdtempSync(join(tmpdir(), 'flowviant-pin-'));
+  const args = [...chromeFlags({ headlessFlag, noSandbox, userDataDir, width, height }), '--remote-debugging-pipe', 'about:blank'];
+  let child;
+  try {
+    child = spawnImpl(browser.bin, args, {
+      stdio: ['ignore', 'ignore', 'pipe', 'pipe', 'pipe'],
+      env: chromeEnv(env),
+      // Its own process group, so the kill below takes Chrome's helpers too.
+      detached: platform() !== 'win32',
+    });
+  } catch (e) {
+    rmSync(userDataDir, { recursive: true, force: true });
+    return { ok: false, reason: 'spawn', message: e.message, launchFailed: true };
+  }
+
+  if (!child.stdio?.[3] || !child.stdio?.[4]) {
+    try { child.kill('SIGKILL'); } catch { /* gone */ }
+    rmSync(userDataDir, { recursive: true, force: true });
+    return { ok: false, reason: 'spawn', message: 'no DevTools pipe to the browser.', launchFailed: true };
+  }
+
+  let err = '';
+  child.stderr?.on('data', (d) => { err = (err + d.toString()).slice(-4000); });
+  const exited = new Promise((resolve) => {
+    if (child.exitCode != null) return resolve();
+    child.once('exit', () => resolve());
+    child.once('error', () => resolve());
+  });
+  const cdp = createCdpClient(child.stdio[3], child.stdio[4]);
+  child.once('exit', (code) => cdp.close(`Chrome exited (code ${code}).`));
+  child.once('error', (e) => cdp.close(e.message));
+  child.stdio[3]?.on?.('error', () => {});
+  child.stdio[4]?.on?.('error', () => {});
+
+  // The browser's whole group (processGroup.mjs). On Windows it is not
+  // detached, the group signal throws there, and the child itself is killed.
+  const kill = () => killGroup(child, 'SIGKILL');
+  const shutdown = async () => {
+    cdp.send('Browser.close').catch(() => {});
+    let grace;
+    const gone = await Promise.race([exited.then(() => true), new Promise((r) => { grace = setTimeout(() => r(false), EXIT_GRACE_MS); })]);
+    clearTimeout(grace);
+    // A browser that closed took its helpers with it; one that did not is
+    // killed with its whole group.
+    if (!gone) kill();
+    cdp.close('closed');
+    for (const fd of [3, 4]) {
+      try { child.stdio[fd]?.destroy?.(); } catch { /* gone */ }
+    }
+    try { child.stderr?.destroy?.(); } catch { /* gone */ }
+    try { rmSync(userDataDir, { recursive: true, force: true }); } catch { /* a dying helper still writing */ }
+  };
+
+  let left = null; // the first sign the page was left, in words
+  const leave = (why) => { if (!left) left = why; };
+  let deadline;
+  const timedOut = new Promise((resolve) => {
+    deadline = setTimeout(() => resolve({ ok: false, reason: 'timeout', message: `the page did not finish within ${timeoutMs / 1000}s.` }), timeoutMs);
+  });
+
+  const run = async () => {
+    try {
+      await cdp.send('Browser.getVersion');
+    } catch (e) {
+      // Give a dying browser a moment to say why on stderr.
+      await Promise.race([exited, new Promise((r) => setTimeout(r, 200))]);
+      const tail = err.trim().split('\n').slice(-2).join(' ');
+      return {
+        ok: false,
+        reason: 'render',
+        message: `Chrome did not start (${e.message})${tail ? ' ' + tail : ''}`,
+        launchFailed: true,
+        sandboxFailed: !noSandbox && SANDBOX_FAILURE_RE.test(err),
+      };
+    }
+
+    let ours = null; // { targetId, sessionId }
+    let ourTargetId = null;
+    let documentSeen = false;
+    const attached = new Map(); // targetId -> { sessionId, waiting, type }
+    let ready;
+    const ourSession = new Promise((r) => { ready = r; });
+    let budgetDone;
+    const budget = new Promise((r) => { budgetDone = r; });
+
+    let navigating = false;
+    // Called only for a target that is paused before it runs. Once the page
+    // is navigating, a new page is one IT opened (a popup) and never runs;
+    // before that, it can only be the window Chrome starts with.
+    const settleForeign = (targetId, info) => {
+      if (info.type === 'page') {
+        if (navigating) leave('the page opened another window');
+        cdp.send('Target.closeTarget', { targetId }).catch(() => {});
+      } else {
+        cdp.send('Runtime.runIfWaitingForDebugger', {}, info.sessionId).catch(() => {});
+      }
+    };
+
+    cdp.on((msg) => {
+      const p = msg.params || {};
+      if (msg.method === 'Target.attachedToTarget' && !msg.sessionId) {
+        const info = { sessionId: p.sessionId, waiting: !!p.waitingForDebugger, type: p.targetInfo?.type };
+        const targetId = p.targetInfo?.targetId;
+        attached.set(targetId, info);
+        if (ourTargetId) {
+          if (targetId === ourTargetId) ready(info.sessionId);
+          else if (info.waiting) settleForeign(targetId, info);
+        }
+        return;
+      }
+      if (!ours || msg.sessionId !== ours.sessionId) return;
+      if (msg.method === 'Fetch.requestPaused') {
+        const requestId = p.requestId;
+        const reqUrl = p.request?.url ?? '';
+        if (p.resourceType === 'Document') {
+          if (!documentSeen && p.frameId === ours.targetId && reqUrl === url) {
+            documentSeen = true;
+            cdp.send('Fetch.continueRequest', { requestId }, ours.sessionId).catch(() => {});
+            return;
+          }
+          leave(`the page navigated to ${reqUrl.slice(0, 200)}`);
+          cdp.send('Fetch.failRequest', { requestId, errorReason: 'BlockedByClient' }, ours.sessionId).catch(() => {});
+          return;
+        }
+        let allowed = false;
+        try {
+          allowed = !!allowSubresource(reqUrl);
+        } catch {
+          allowed = false;
+        }
+        cdp.send(allowed ? 'Fetch.continueRequest' : 'Fetch.failRequest', allowed ? { requestId } : { requestId, errorReason: 'BlockedByClient' }, ours.sessionId).catch(() => {});
+        return;
+      }
+      if (msg.method === 'Emulation.virtualTimeBudgetExpired') budgetDone();
+    });
+
+    await cdp.send('Browser.setDownloadBehavior', { behavior: 'deny' }).catch(() => {});
+    await cdp.send('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+    const created = await cdp.send('Target.createTarget', { url: 'about:blank' });
+    ourTargetId = created.targetId;
+    for (const [targetId, info] of attached) {
+      if (targetId === ourTargetId) ready(info.sessionId);
+      else if (info.waiting) settleForeign(targetId, info);
+    }
+    // A Chrome that does not auto-attach the page it just made is attached
+    // to it by hand.
+    let attachWait;
+    const sessionId = await Promise.race([
+      ourSession,
+      new Promise((r) => { attachWait = setTimeout(r, ATTACH_WAIT_MS, null); }),
+    ]).then((id) => id ?? cdp.send('Target.attachToTarget', { targetId: ourTargetId, flatten: true }).then((a) => a.sessionId));
+    clearTimeout(attachWait);
+    ours = { targetId: ourTargetId, sessionId };
+
+    await cdp.send('Page.enable', {}, sessionId);
+    await cdp.send('Fetch.enable', { patterns: [{ urlPattern: '*', requestStage: 'Request' }] }, sessionId);
+    await cdp.send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: false }, sessionId);
+    await cdp.send('Emulation.setVirtualTimePolicy', { policy: 'pause' }, sessionId);
+    await cdp.send('Runtime.runIfWaitingForDebugger', {}, sessionId).catch(() => {});
+    navigating = true;
+    const nav = await cdp.send('Page.navigate', { url }, sessionId);
+    if (nav.errorText) {
+      return { ok: false, reason: 'render', message: `the page did not load (${nav.errorText}).` };
+    }
+    // Let fonts and scripts settle, as `--virtual-time-budget` does.
+    await cdp.send('Emulation.setVirtualTimePolicy', { policy: 'pauseIfNetworkFetchesPending', budget: budgetMs }, sessionId);
+    // A Chrome that never reports the budget is captured on the wall clock,
+    // short of the deadline, rather than never.
+    let wall;
+    await Promise.race([budget, new Promise((r) => { wall = setTimeout(r, Math.max(budgetMs, timeoutMs - EXIT_GRACE_MS)); })]);
+    clearTimeout(wall);
+
+    const history = await cdp.send('Page.getNavigationHistory', {}, sessionId);
+    const current = history.entries?.[history.currentIndex]?.url ?? '';
+    const tree = await cdp.send('Page.getFrameTree', {}, sessionId);
+    const main = tree.frameTree?.frame ?? {};
+    if (!documentSeen) leave('the page was never requested');
+    if (!sameDocument(current, url) || !sameDocument(main.url ?? '', url) || main.unreachableUrl) {
+      leave(`the page ended on ${String(current || main.url || 'nothing').slice(0, 200)}`);
+    }
+    if (left) return { ok: false, reason: 'left-page', message: `${left}.` };
+
+    const shot = await cdp.send('Page.captureScreenshot', { format: 'png' }, sessionId);
+    // One last look: a navigation that landed during the capture.
+    if (left) return { ok: false, reason: 'left-page', message: `${left}.` };
+    writeFileSync(out, Buffer.from(shot.data ?? '', 'base64'));
+    return { ok: true, path: out };
+  };
+
+  try {
+    return await Promise.race([
+      run().catch((e) => ({ ok: false, reason: 'render', message: e?.message ?? String(e) })),
+      timedOut,
+    ]);
+  } finally {
+    clearTimeout(deadline);
+    await shutdown();
+  }
+}
+
+/**
+ * Capture `url` and nothing else to a PNG at `out` (see the header). Resolves
+ * `{ ok: true, path }` or `{ ok: false, reason, message }`; a reason of
+ * 'left-page' means the page tried to become something else.
+ *
+ * `browser`, `spawn`, `uid` and `env` are injectable for the tests; nothing in
+ * the daemon passes them.
+ */
+export async function capturePinnedPage({
+  url,
+  out,
+  width = 1440,
+  height = 900,
+  timeoutMs = 60_000,
+  budgetMs = 5_000,
+  allowSubresource = () => false,
+  browser = resolveBrowser(),
+  spawn: spawnImpl = spawn,
+  uid = process.getuid?.(),
+  env = process.env,
+}) {
+  if (!browser) {
+    return { ok: false, reason: 'no-browser', message: 'No Chrome/Chromium/Edge found.' };
+  }
+  if (browser.viaWindows) {
+    return { ok: false, reason: 'wsl', message: 'a Windows browser reached through WSL cannot be held to one page.' };
+  }
+  let noSandbox = sandboxOff({ uid, env });
+  let last = null;
+  for (const headlessFlag of ['--headless=new', '--headless']) {
+    const once = () =>
+      captureOnce(browser, { url, out, width, height, timeoutMs, budgetMs, allowSubresource, headlessFlag, noSandbox }, { spawnImpl, env });
+    let r = await once();
+    if (!r.ok && r.sandboxFailed) {
+      noSandbox = true; // sticky: the one retry this capture gets
+      r = await once();
+    }
+    const { launchFailed, sandboxFailed: _measured, ...result } = r;
+    // Only a browser that never answered is worth another launch; a page that
+    // left, timed out or failed to load answers the same under any flag.
+    if (result.ok || !launchFailed) return result;
+    last = result;
+  }
+  return last;
+}

package/bin/lib/planDependencies.mjs

@@ -0,0 +1,70 @@
+/** The planner declares prerequisites; the daemon enforces them without reading
+ * human prose. Declared collisions use the same compatible groups; evidence stays on the wire. */
+export function groupDependencies(agents, dependencies, collisions) {
+  if (dependencies === undefined && collisions === undefined) return agents;
+  if (dependencies === undefined) dependencies = [];
+  if (collisions === undefined) collisions = [];
+  if (!Array.isArray(collisions) || collisions.length > 1200) return null;
+  if (!Array.isArray(dependencies) || dependencies.length > 1200) return null;
+  if (!dependencies.length && !collisions.length) return agents;
+  const owner = new Map();
+  for (const [i, group] of agents.entries()) {
+    for (const id of group.taskIds) {
+      if (owner.has(id)) return null;
+      owner.set(id, i);
+    }
+  }
+  const parents = agents.map((_, i) => i);
+  const root = (i) => {
+    while (parents[i] !== i) i = parents[i];
+    return i;
+  };
+  const needs = new Map();
+  for (const edge of dependencies) {
+    if (!edge || !owner.has(edge.taskId) || !Array.isArray(edge.requires) || edge.requires.length > 60) return null;
+    for (const id of edge.requires) {
+      if (!owner.has(id) || id === edge.taskId) return null;
+      const a = root(owner.get(edge.taskId));
+      const b = root(owner.get(id));
+      parents[Math.max(a, b)] = Math.min(a, b);
+      if (!needs.has(edge.taskId)) needs.set(edge.taskId, new Set());
+      needs.get(edge.taskId).add(id);
+    }
+  }
+  for (const collision of collisions) {
+    if (!collision || !Array.isArray(collision.taskIds) || new Set(collision.taskIds).size < 2 || collision.taskIds.length > 60) return null;
+    for (const id of collision.taskIds) {
+      if (!owner.has(id)) return null;
+      const a = root(owner.get(collision.taskIds[0]));
+      const b = root(owner.get(id));
+      parents[Math.max(a, b)] = Math.min(a, b);
+    }
+  }
+  const groups = new Map();
+  for (const [i, group] of agents.entries()) {
+    const key = root(i);
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(group);
+  }
+  const result = [];
+  for (const members of groups.values()) {
+    const attached = [...new Set(members.map((g) => g.intoAgentId).filter(Boolean))];
+    if (attached.length > 1) return null;
+    const pending = members.flatMap((g) => g.taskIds);
+    if (pending.length > 60) return null;
+    const taskIds = [];
+    // Stable topological order: unrelated cards keep their proposed order.
+    while (pending.length) {
+      const at = pending.findIndex((id) => [...(needs.get(id) ?? [])].every((need) => taskIds.includes(need)));
+      if (at < 0) return null; // a cycle cannot become a runnable proposal
+      taskIds.push(...pending.splice(at, 1));
+    }
+    const budget = members.reduce((sum, g) => sum + (g.pointsBudget ?? 0), 0);
+    result.push({ ...members[0], taskIds,
+      ...(members.some(g => g.rationale) ? { rationale: members.map(g => g.rationale).filter(Boolean).join('\n').slice(0, 1000) } : {}),
+      ...(budget ? { pointsBudget: Math.min(budget, 100_000) } : {}),
+      ...(attached.length ? { intoAgentId: attached[0] } : {}),
+    });
+  }
+  return result;
+}

package/bin/lib/postureTools.mjs

@@ -0,0 +1,85 @@
+/** Per-turn readout of mounted tools and remaining permission boundaries.
+ * Kind selects the delivery contract; CLI/configuration and the filesystem
+ * fence determine supporting capabilities. Keep these claims beside the
+ * actual builders and the spawned-lane tests in artifactProjectMcp.test.mjs.
+ */
+
+/** What the machine's own MCP servers are, per CLI. */
+const MACHINE = {
+  claude: 'the MCP servers and claude.ai connectors this machine’s Claude Code has (its user and local servers)',
+  codex: 'the MCP servers in this machine’s Codex config',
+};
+
+/** Per posture and CLI: what the card has and what it lacks. */
+const POSTURES = {
+  research: {
+    claude: {
+      has: 'the repository’s files (never .env files), the project’s knowledge library, web search and web fetch, and writing under .flowviant/artifacts/ and the granted scratch directory',
+      lacks: 'no measured native image-generation tool, no delegation, guarded read commands only (no helper scripts or browsers), and no plugins from this machine’s Claude Code (nor the MCP servers a plugin brings)',
+    },
+    codex: {
+      has: 'a sandboxed shell over an isolated copy of the repository (no .env, credential or git files, and no network from the shell), web search, and writing under .flowviant/artifacts/ and the granted scratch directory',
+      lacks: 'no host files outside that copy except native generated images; native image generation depends on this CLI and account',
+    },
+  },
+  design: {
+    claude: {
+      has: 'the repository’s files (never .env files), the project’s knowledge library, guarded read commands, web search and web fetch, and writing under .flowviant/artifacts/ and the granted scratch directory',
+      lacks: 'no measured native image-generation tool, no delegation, no helper scripts or browsers, and no plugins from this machine’s Claude Code (nor the MCP servers a plugin brings)',
+    },
+    codex: {
+      has: 'a sandboxed shell that reads the repository and writes only under .flowviant/artifacts/, with no shell network, scratch writes, and native image generation when this CLI and account expose it',
+      lacks: 'no native web on this broad-read fence (host credentials are readable); use a configured project web MCP server when available',
+    },
+  },
+  image: {
+    codex: {
+      has: 'a sandboxed shell that reads the repository and writes only under .flowviant/artifacts/, with no shell network, scratch writes, and native image generation when this CLI and account expose it',
+      lacks: 'no web',
+    },
+  },
+};
+
+/** Configuration supplies tools; a skill supplies instructions, not a tool. */
+const SUPPORTING_CAPABILITIES = `The kind defines the delivered product, not which supporting capabilities
+may be used. Use available tools needed for the person's request, including
+native image generation for requested textures or illustrations. A listed skill
+is not proof that its tool is installed, mounted or entitled on this account.
+Do not re-file the kind or require a separate image card just to use a tool.
+If a needed tool is absent or fails, relay the measured limitation and ask for
+the missing configuration or a decision. A separately billed CLI/API fallback
+requires the person's explicit choice first; never default to OPENAI_API_KEY.
+Use personal connectors only for the requested work; sending messages or other
+external writes requires explicit authorization. Never open the person's browser
+or desktop; headless inspection must stay within the granted filesystem fence.
+Delegation is disabled by policy on fenced turns; tool names may still be listed. Complete the work in this turn.`;
+
+const list = (names) => names.join(', ');
+
+/**
+ * The note for a turn, or '' when its posture withholds nothing to say.
+ * `mounted` is the names of the base `.mcp.json` servers this turn mounted;
+ * `machine` whether the machine's own servers were mounted beside them (a
+ * Claude turn whose `.mcp.json` walk could not be bounded mounts the base copy
+ * alone); `unmounted` is `[{ name, reason, source }]` for the servers it
+ * could not mount — `source` 'project' (the base `.mcp.json`) or 'machine'.
+ */
+export function postureToolsNote({ posture, runtime, mounted = [], machine = true, unmounted = [] }) {
+  const row = POSTURES[posture]?.[runtime];
+  if (!row) return posture === 'build' ? `TOOLS ON THIS CARD. Use the tools actually exposed by this CLI and its configuration. ${SUPPORTING_CAPABILITIES.replace('Delegation is disabled by policy on fenced turns; tool names may still be listed. Complete the work in this turn.', 'Delegate only when the person explicitly requests it.')} ` : '';
+  const fromProject = unmounted.filter((u) => u.source !== 'machine');
+  const fromMachine = unmounted.filter((u) => u.source === 'machine');
+  const project = mounted.length
+    ? `The project’s MCP servers from the base branch’s .mcp.json are mounted: ${list(mounted)}.`
+    : fromProject.length
+      ? 'None of the project’s MCP servers is mounted on this machine.'
+      : 'The base branch’s .mcp.json lists no MCP server.';
+  const own = machine
+    ? ` So are ${MACHINE[runtime]}.`
+    : ` ${MACHINE[runtime][0].toUpperCase()}${MACHINE[runtime].slice(1)} are not mounted on this turn.`;
+  const missing = (rows, where) => (rows.length ? ` ${where}, but not mounted here: ${list(rows.map(({ name, reason }) => `${name} (${reason})`))}.` : '');
+  return `TOOLS ON THIS CARD. You have ${row.has}. You have ${row.lacks}. ${project}${own}${missing(fromProject, 'Listed in the base branch’s .mcp.json')}${missing(fromMachine, `In ${MACHINE[runtime]}`)} A server added to .mcp.json only in this worktree is not mounted; the base branch’s file is the one that counts.
+There is no Flowviant setting that adds a tool, so never invent one. A missing
+server can be configured in the base branch's .mcp.json or the machine's CLI.
+${SUPPORTING_CAPABILITIES}`;
+}