flowviant 0.33.0 → 0.34.0

package/bin/lib/config.mjs

@@ -3,7 +3,7 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { homedir } from 'node:os';
+import { homedir, cpus } from 'node:os';
 
 // Read the daemon's version from its OWN package.json (always shipped in the npm
 // tarball) — never hardcode it. The hardcoded constant drifted: it sat at
@@ -58,6 +58,32 @@ export const STREAM_URL =
   process.env.FLOWVIANT_STREAM_URL ||
   FLEET_URL.replace(/\/agents(\/?)$/, '/stream$1').replace(/^http/, 'ws');
 export const POLL_SECONDS = Number(process.env.POLL_SECONDS || 20);
+
+/**
+ * How many tasks THIS MACHINE will build at once.
+ *
+ * The limit belongs here, not on the server: a task in flight is a Claude Code
+ * session plus its own git worktree plus whatever the project's dev server and
+ * tests want, and this process is the only party that can see the cores, the
+ * RAM and the fan. The server used to decide it, indirectly, by how many lanes
+ * a user had pre-sized with a dial — which asked them to answer a question
+ * about their laptop in a web app, before they knew what they were going to
+ * dispatch.
+ *
+ * Sent to the server on every roster poll so it can grow lanes to meet waiting
+ * work UNDER this ceiling, and enforced locally besides — the roster can carry
+ * more lanes than this (someone added capacity by hand, or a second machine
+ * shares the fleet), and a ceiling that only exists as a request is not one.
+ *
+ * Half the cores, floor 1, cap 4. Half because a build agent is not the only
+ * thing running — the user is working on this machine too — and 4 because past
+ * that the shared Claude account, not the CPU, is what runs out.
+ */
+export const MAX_CONCURRENT = (() => {
+  const asked = Number(process.env.FLOWVIANT_MAX_CONCURRENT);
+  if (Number.isFinite(asked) && asked >= 1) return Math.min(Math.floor(asked), 32);
+  return Math.max(1, Math.min(4, Math.floor((cpus().length || 2) / 2)));
+})();
 export const IDLE_SECONDS = Number(process.env.IDLE_SECONDS || 30);
 // Live mode: after this long idle-parked on a blocker, tear the session down to
 // free the Claude process (the intent stays claimed; it resumes when answered).

package/bin/lib/fleet.mjs

@@ -18,6 +18,7 @@ import {
   MCP_URL,
   SAFE,
   POLL_SECONDS,
+  MAX_CONCURRENT,
   IDLE_SECONDS,
   RECONCILE_SECONDS,
   REFRESH_BEFORE_SECONDS,
@@ -76,6 +77,11 @@ import { processDeployJobs, reportDeployConfig } from './deploy.mjs';
 async function fetchRoster(haveIds) {
   const url = new URL(FLEET_URL);
   if (haveIds.length) url.searchParams.set('have', haveIds.join(','));
+  // What this machine will run at once. The server grows lanes to meet waiting
+  // work beneath this, instead of the user pre-sizing a pool by hand — only the
+  // machine knows its cores, its RAM and whose Claude quota is being spent.
+  // Older servers ignore the param, so sending it is always safe.
+  url.searchParams.set('capacity', String(MAX_CONCURRENT));
   // Env-sync identity + materialized version (the Settings "env vN" chip).
   try {
     for (const [k, v] of Object.entries(await envQueryParams())) {
@@ -1170,6 +1176,7 @@ export async function runFleetDaemon() {
   let connected = false; // log the first successful poll once
   let rosterSig = null; // last roster membership, to log changes only
   let idleBeatAt = 0; // throttle the "still alive" idle heartbeat
+  let cappedWarned = false; // say once, not every reconcile, why extra lanes idle
   let joinCount = 0; // for stable per-agent label colours
 
   // ── Push channel: a server wake short-circuits the reconcile sleep so a job is
@@ -1296,6 +1303,23 @@ export async function runFleetDaemon() {
       }
       hasWorkByAgent.set(a.agentId, !!a.hasWork);
       if (!workers.has(a.agentId)) {
+        // Local ceiling, enforced and not merely requested. The roster can carry
+        // more lanes than this machine asked for — someone added capacity by
+        // hand, or a second machine shares the fleet — and each extra worker is
+        // another Claude session, another worktree and another dev server on
+        // somebody's laptop. Skipping the spawn does NOT strand the work: an
+        // @mention addresses the FLEET, so any running lane can claim it; the
+        // tasks queue behind the ones we did start.
+        if (workers.size >= MAX_CONCURRENT) {
+          if (!cappedWarned) {
+            cappedWarned = true;
+            info(
+              `running ${MAX_CONCURRENT} task${MAX_CONCURRENT === 1 ? '' : 's'} at a time on this machine — ` +
+                `more will queue (FLOWVIANT_MAX_CONCURRENT to change)`
+            );
+          }
+          continue;
+        }
         const wt = join(baseDir, `agent-${a.agentId}`);
         try {
           if (!existsSync(wt)) {

package/bin/lib/live.mjs

@@ -138,10 +138,15 @@ This IS your handover, so make it tangible; match the evidence to what you built
 • UI / any visible screen → attach a real SCREENSHOT. Start the app's dev server
   in your worktree, then capture it headlessly with
   \`flowviant shot http://localhost:<PORT>/<route> --out shot.png\` (it finds a
-  browser for you and never needs a display), and attach_evidence with kind
-  "screenshot" and the file's base64 (\`base64 -w0 shot.png\`). Shoot EVERY key
-  screen you changed. If \`flowviant shot\` reports that no browser is available,
-  do NOT block — fall back to the text evidence below.
+  browser for you and never needs a display). THEN READ shot.png BACK AND LOOK
+  AT IT before you attach — you can see images, and this is the only moment
+  anyone checks the thing you are about to call proof. A blank page, a 404, an
+  error overlay, a collapsed layout and the screen you meant all look identical
+  as a file path. If it is wrong, fix the code and shoot again; if it is right,
+  attach_evidence with kind "screenshot" and the file's base64
+  (\`base64 -w0 shot.png\`). Shoot EVERY key screen you changed. If
+  \`flowviant shot\` reports that no browser is available, do NOT block — fall
+  back to the text evidence below.
 • backend / API work → a request/response capture or a data sample showing the
   write (kind "request_response" or "sample").
 • a multi-step FLOW (login, signup, checkout): one screenshot does NOT prove it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "Run your own Claude Code as headless build agents for Flowviant — on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
   "type": "module",
   "bin": {