flowviant 0.102.0 → 0.103.0

package/bin/cli.mjs

@@ -170,6 +170,8 @@ if (process.argv[2] === 'login') {
 }
 
 if (process.argv[2] === 'status' && process.argv.includes('--json')) {
+  // The tray polls this every 30 s: the fixed per-user bin dirs only, no shell.
+  await (await import('./lib/loginPath.mjs')).adoptLoginPathForProcess({ shell: false });
   const { desktopStatus, desktopStatusRemote } = await import('./lib/desktopContract.mjs');
   const status = process.argv.includes('--remote') ? await desktopStatusRemote() : desktopStatus();
   process.stdout.write(`${JSON.stringify(status)}\n`);
@@ -178,6 +180,7 @@ if (process.argv[2] === 'status' && process.argv.includes('--json')) {
 
 // `flowviant status` — the same facts, for a person.
 if (process.argv[2] === 'status') {
+  await (await import('./lib/loginPath.mjs')).adoptLoginPathForProcess();
   const { runStatus } = await import('./lib/views.mjs');
   await runStatus();
   process.exit(0);
@@ -199,6 +202,7 @@ if (process.argv[2] === 'open') {
 
 // `flowviant doctor` — what this computer needs, checked.
 if (process.argv[2] === 'doctor') {
+  await (await import('./lib/loginPath.mjs')).adoptLoginPathForProcess();
   const { runDoctor } = await import('./lib/views.mjs');
   process.exit((await runDoctor()) > 0 ? 1 : 0);
 }
@@ -561,6 +565,10 @@ if (process.argv[2] && !process.argv[2].startsWith('-')) {
   process.exit(1);
 }
 
+// Find the CLIs where the person's own terminal would: the Windows tray starts
+// this through `wsl.exe --`, which reads no shell startup file (loginPath.mjs).
+await (await import('./lib/loginPath.mjs')).adoptLoginPathForProcess();
+
 // ── WHICH PROJECT THIS START SERVES — said, asked, or refused; never guessed.
 //
 // The store holds many projects since 0.55.0 and resolution is BY REPO

package/bin/lib/fleet.mjs

@@ -41,19 +41,7 @@ import { projectLabel, safeName, setStoredProjectName } from './credentials.mjs'
 import { credentialRejected } from './authReject.mjs';
 import { handleVersionSignal, cmpVersion } from './update.mjs';
 import { emitMachineEvent, writeDaemonState } from './desktopContract.mjs';
-import {
-  git,
-  gitNetAsync,
-  resetWorktree,
-  repoRootOrDie,
-  detectBaseRef,
-  originSlug,
-  baseBranchName,
-  isValidPrUrl,
-  isValidBranch,
-  isSafePathSegment,
-  excludeInWorktree,
-} from './git.mjs';
+import { git, gitNetAsync, resetWorktree, repoRootOrDie, detectBaseRef, originSlug, baseBranchName, isValidPrUrl, isValidBranch, isSafePathSegment, excludeInWorktree, usableBaseRef } from './git.mjs';
 import { c, info, note, ok, warn, fail } from './ui.mjs';
 import { revertPatch, withPatchLock } from './patch.mjs';
 import {
@@ -2678,7 +2666,7 @@ export async function runFleetDaemon({ afterLock = null } = {}) {
      * thing worse than not offering the choice at all.
      */
     if (typeof roster.baseBranch === 'string' && roster.baseBranch.trim()) {
-      const want = `origin/${baseBranchName(roster.baseBranch.trim())}`;
+      const want = usableBaseRef(repoRoot, `origin/${baseBranchName(roster.baseBranch.trim())}`);
       if (want !== baseRef) {
         note(`base   · ${want} ${c.dim('(set for this project)')}`);
         baseRef = want;

package/bin/lib/git.mjs

@@ -250,12 +250,43 @@ export function detectBaseRef(repoRoot) {
     }
   }
   try {
-    return `origin/${git(['rev-parse', '--abbrev-ref', 'HEAD'], repoRoot)}`;
+    return usableBaseRef(repoRoot, `origin/${git(['rev-parse', '--abbrev-ref', 'HEAD'], repoRoot)}`);
   } catch {
     return 'HEAD';
   }
 }
 
+/**
+ * A base ref an agent's worktree can actually be cut from.
+ *
+ * `origin/<branch>` is the right base when the repo HAS an origin. A repo with
+ * no remote (a local-only project — the owner's "Death Note - Roblox",
+ * 2026-09-25) has no `origin/*` refs at all, and cutting a worktree from one
+ * fails; every agent turn then ended "nothing" in a second. So: the ref itself
+ * when it resolves to a commit, else the LOCAL branch of the same name, else
+ * the ref unchanged (and the worktree step says why in git's words).
+ */
+export function usableBaseRef(repoRoot, ref) {
+  const resolves = (r) => {
+    try { git(['rev-parse', '--verify', '--quiet', `${r}^{commit}`], repoRoot); return true; } catch { return false; }
+  };
+  if (resolves(ref)) return ref;
+  const local = String(ref).replace(/^origin\//, '');
+  if (local !== ref && resolves(local)) return local;
+  return ref;
+}
+
+/** True when the repository has at least one commit (HEAD resolves). */
+export function hasCommits(repoRoot) {
+  try { git(['rev-parse', '--verify', '--quiet', 'HEAD^{commit}'], repoRoot); return true; } catch { return false; }
+}
+
+/** The last line git wrote to stderr for a failed call, or its message. */
+export function gitFailure(error) {
+  const stderr = String(error?.stderr ?? '').trim().split('\n').filter(Boolean);
+  return stderr.at(-1) ?? String(error?.message ?? error).split('\n')[0];
+}
+
 /**
  * The BRANCH NAME behind a base ref.
  *

package/bin/lib/loginPath.mjs

@@ -0,0 +1,116 @@
+/**
+ * THE PATH A PERSON'S TERMINAL HAS, for a daemon nobody started from one.
+ *
+ * Every CLI is found by name on PATH (`claude --version`, `codex`, `agy`,
+ * `gh`). A terminal's PATH comes from the shell's startup files; the Windows
+ * tray starts the daemon with `wsl.exe -d <distro> -- <binary>`, which reads
+ * none of them. That PATH is the distro's bare default, and it misses exactly
+ * where the CLIs usually live: `~/.local/bin` (Claude Code's own installer,
+ * put on PATH by ~/.profile) and version managers set up in ~/.bashrc (nvm,
+ * volta, bun). So a machine whose `claude` works in the owner's WSL terminal
+ * measured "not installed" under the tray (2026-09-25).
+ *
+ * So the daemon asks the person's login shell for its PATH once, and keeps
+ * every entry it already had FIRST (a terminal start is unchanged) with the
+ * shell's additions after it; then the usual per-user bin directories that
+ * exist. Best-effort and bounded: a shell that hangs or prints nothing costs a
+ * few seconds once, and nothing is ever removed from PATH.
+ */
+
+import { execFileSync, spawn } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+
+const MARK = '__FLOWVIANT_PATH__=';
+
+/** The PATH an interactive login shell ends up with, or null. */
+export function loginShellPath({ env = process.env, exec = execFileSync, timeoutMs = 4000 } = {}) {
+  const shell = env.SHELL && env.SHELL.startsWith('/') ? env.SHELL : '/bin/bash';
+  try {
+    // -i so ~/.bashrc runs (nvm lives there, behind the "not interactive?
+    // return" guard); -l so ~/.profile runs (~/.local/bin lives there). The
+    // marker line survives whatever a startup file prints.
+    const out = String(exec(shell, ['-ilc', `printf '\\n${MARK}%s\\n' "$PATH"`], {
+      env: { ...env, TERM: 'dumb' },
+      timeout: timeoutMs,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }));
+    const line = out.split('\n').reverse().find((l) => l.startsWith(MARK));
+    const value = line?.slice(MARK.length).trim();
+    return value ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Per-user bin directories CLIs install into, that exist on this box. */
+export function userBinDirs({ home = homedir(), exists = existsSync, list = readdirSync } = {}) {
+  const dirs = ['.local/bin', '.npm-global/bin', '.bun/bin', '.volta/bin', '.cargo/bin'].map((d) => join(home, d));
+  // nvm: the newest installed node's bin (nvm's own "default" needs its shell
+  // function to resolve; the newest is the usual answer and only a fallback).
+  try {
+    const versions = list(join(home, '.nvm/versions/node'))
+      .filter((v) => /^v\d+\.\d+\.\d+$/.test(v))
+      .sort((a, b) => {
+        const pa = a.slice(1).split('.').map(Number);
+        const pb = b.slice(1).split('.').map(Number);
+        return pb[0] - pa[0] || pb[1] - pa[1] || pb[2] - pa[2];
+      });
+    if (versions[0]) dirs.push(join(home, '.nvm/versions/node', versions[0], 'bin'));
+  } catch { /* no nvm */ }
+  return dirs.filter((d) => exists(d));
+}
+
+/** Current entries first, then any the others add. Order-preserving, deduped. */
+export function mergePath(current, ...more) {
+  const seen = new Set();
+  const out = [];
+  for (const part of [current, ...more].flatMap((p) => (Array.isArray(p) ? p : String(p ?? '').split(':')))) {
+    if (!part || seen.has(part)) continue;
+    seen.add(part);
+    out.push(part);
+  }
+  return out.join(':');
+}
+
+/**
+ * Widen process.env.PATH in place. `shell: false` skips the login shell and
+ * only adds the fixed per-user directories (for the tray's frequent status
+ * polls, where a shell start every 30 s is not worth it).
+ */
+export function adoptLoginPath({ shell = true, env = process.env, ...deps } = {}) {
+  if (platform() === 'win32' || env.FLOWVIANT_KEEP_PATH === '1') return env.PATH;
+  const login = shell ? loginShellPath({ env, ...deps }) : null;
+  env.PATH = mergePath(env.PATH, login, userBinDirs(deps));
+  return env.PATH;
+}
+
+/**
+ * adoptLoginPath, for THIS process and every child it will start.
+ *
+ * Under Bun (the compiled binary the curl install and the tray ship) child
+ * processes are looked up and started with the environment the process
+ * STARTED with unless a spawn passes `env` — a later `process.env.PATH = …` is
+ * invisible to them (measured 2026-09-25: node found ~/.local/bin/claude after
+ * the change, the compiled binary did not). So when the PATH grew, the
+ * binary restarts itself once with it: a thin proxy, the same shape as the
+ * self-update re-exec, stdio inherited, exit code and signals passed through.
+ * Node needs none of that and adopts in place.
+ */
+export async function adoptLoginPathForProcess(opts = {}) {
+  if (process.env.FLOWVIANT_PATH_ADOPTED === '1') return;
+  const before = process.env.PATH;
+  const after = adoptLoginPath(opts);
+  if (!process.versions.bun || after === before) return;
+  const compiled = process.argv[1]?.startsWith('/$bunfs/');
+  const child = spawn(process.execPath, process.argv.slice(compiled ? 2 : 1), {
+    stdio: 'inherit',
+    env: { ...process.env, FLOWVIANT_PATH_ADOPTED: '1' },
+  });
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(signal, () => { try { child.kill(signal); } catch { /* gone */ } });
+  }
+  const code = await new Promise((resolve) => child.on('exit', (status, signal) => resolve(status ?? (signal ? 1 : 0))));
+  process.exit(code);
+}

package/bin/lib/shipMerge.mjs

@@ -40,6 +40,34 @@ export function mergeOutward({
       /* not there — fine */
     }
   };
+  const hasOrigin = () => {
+    try { git(['remote', 'get-url', 'origin'], repoRoot); return true; } catch { return false; }
+  };
+  /**
+   * A REPOSITORY WITH NO REMOTE (2026-09-25). There is nowhere to push, so the
+   * merge lands on the local base branch itself. If base is checked out in the
+   * project folder it FAST-FORWARDS there, and only over a tree with no
+   * uncommitted tracked changes (refused in words otherwise: moving a branch
+   * under someone's edits is not a merge anybody approved); if it is not
+   * checked out, the ref moves by compare-and-swap. Either way nothing is
+   * rewritten, and `--no-ff` above kept every receipt's commit.
+   */
+  const landLocally = () => {
+    const base = baseBranchName(baseRef());
+    const merged = String(git(['rev-parse', 'HEAD'], tmpDir)).trim();
+    const before = String(git(['rev-parse', `refs/heads/${base}`], repoRoot)).trim();
+    let current = null;
+    try { current = String(git(['symbolic-ref', '--quiet', '--short', 'HEAD'], repoRoot)).trim(); } catch { /* detached */ }
+    if (current === base) {
+      const dirty = String(git(['status', '--porcelain', '--untracked-files=no'], repoRoot)).trim();
+      if (dirty) {
+        throw new Error(`this repository has no remote, so the merge lands on ${base} in ${repoRoot} itself, and that checkout has uncommitted changes. Commit or stash them, then approve again.`);
+      }
+      git(['merge', '--ff-only', merged], repoRoot);
+    } else {
+      git(['update-ref', `refs/heads/${base}`, merged, before], repoRoot);
+    }
+  };
   const attempt = () => {
     dropTmp();
     git(['worktree', 'add', '--detach', tmpDir, baseRef()], repoRoot);
@@ -47,7 +75,8 @@ export function mergeOutward({
       ['merge', '--no-ff', tip, '-m', `ship(${label}): ${count} commit${count === 1 ? '' : 's'}`],
       tmpDir
     );
-    gitNet(['push', 'origin', `HEAD:${baseBranchName(baseRef())}`], tmpDir, 120_000);
+    if (hasOrigin()) gitNet(['push', 'origin', `HEAD:${baseBranchName(baseRef())}`], tmpDir, 120_000);
+    else landLocally();
   };
   try {
     try {
@@ -132,5 +161,7 @@ export function mergeOutward({
  */
 export function isRaceRejection(e) {
   const d = `${e?.stdout ?? ''}\n${e?.stderr ?? ''}\n${e?.message ?? ''}`;
-  return /non-fast-forward|\[rejected\]|fetch first|stale info/i.test(d);
+  // `but expected` is update-ref's compare-and-swap losing (a repo with no
+  // remote, where the base ref moved between our read and our write).
+  return /non-fast-forward|\[rejected\]|fetch first|stale info|but expected/i.test(d);
 }

package/bin/lib/views.mjs

@@ -194,6 +194,29 @@ export async function runDoctor({ cwd = process.cwd(), fetchImpl = fetch } = {})
     entry ? `Connected to ${projectLabel(entry)}` : 'This repo is not connected to a project',
     'Run `flowviant login` here and approve it in your browser.');
 
+  // EVERY COPY ON THIS BOX, and which one a daemon runs from. An old copy with a
+  // live daemon is the usual reason the app reports a version older than the
+  // one just installed: `uninstall --others` skips a copy a daemon runs from,
+  // and a global npm install that needed sudo cannot update itself.
+  try {
+    const { buildUninstallPlan } = await import('./uninstall.mjs');
+    const plan = await buildUninstallPlan();
+    const copies = plan.copies.filter((copy) => copy.kind !== 'path-line');
+    for (const copy of copies) {
+      const where = copy.kind === 'npm-global' ? 'npm global' : copy.kind === 'npx-cache' ? 'npx cache' : 'binary';
+      const running = copy.runningPid ? `, a daemon runs from it (pid ${copy.runningPid})` : '';
+      const older = copy.version && olderVersion(copy.version, VERSION);
+      const text = `flowviant ${copy.version ?? '(unknown version)'} · ${where} · ${copy.path}${copy.current ? ' (this one)' : ''}${running}`;
+      if (older && copy.runningPid) {
+        add(false, text, `An older daemon is serving. Run \`flowviant stop\`, then \`flowviant uninstall --others\`${copy.kind === 'npm-global' ? ' (if npm refuses, `sudo npm uninstall -g flowviant`)' : ''}, then start flowviant again.`);
+      } else if (older) {
+        add(false, text, `An older copy. Remove it with \`flowviant uninstall --others\`${copy.kind === 'npm-global' ? ' (if npm refuses, `sudo npm uninstall -g flowviant`)' : ''}.`);
+      } else {
+        add(true, text);
+      }
+    }
+  } catch { /* the listing is best-effort */ }
+
   const health = String(FLEET_URL).replace(/\/api\/.*$/, '/health');
   let reach = null;
   try {

package/bin/lib/work.mjs

@@ -48,15 +48,7 @@ import {
   DAEMON_INSTANCE,
   MACHINE_HOST,
 } from './config.mjs';
-import {
-  git,
-  gitRaw,
-  gitNet as gitNetIn,
-  gitNetAsync,
-  splitNul,
-  isSafePathSegment,
-  excludeInWorktree,
-} from './git.mjs';
+import { git, gitRaw, gitNet as gitNetIn, gitNetAsync, splitNul, isSafePathSegment, excludeInWorktree, hasCommits, gitFailure } from './git.mjs';
 import {
   publishPushArgs,
   publishFetchArgs,
@@ -1647,7 +1639,12 @@ export function createWorkManager({
         } catch {
           try {
             git(['worktree', 'add', '-b', branch, wt, at], repoRoot);
-          } catch {
+          } catch (e) {
+            // Kept for the caller to SAY: an agent turn that cannot get a
+            // worktree used to end "nothing" with no words at all.
+            placeWtFor.lastError = hasCommits(repoRoot)
+              ? `git could not create the worktree from ${at}: ${gitFailure(e)}`
+              : `the repository ${repoRoot} has no commits yet, so there is nothing to branch from. Make a first commit there, then send the agent any message to try again.`;
             return null;
           }
         }

package/bin/lib/workAgentTurns.mjs

@@ -246,7 +246,7 @@ export function createWorkAgentTurns({
     const agentId = String(job.agentId || '');
     const place = String(job.placeId || '');
     if (!isSafePathSegment(place)) {
-      await postAgentTurn({ turnId, outcome: 'nothing' });
+      await postAgentTurn({ turnId, outcome: 'nothing', answer: 'the machine was handed a turn for a place it will not use as a folder name' });
       return;
     }
     /**
@@ -375,9 +375,11 @@ export function createWorkAgentTurns({
       }
       const dir = placeWtFor(place);
       if (!dir) {
-        // No worktree and none could be cut. `nothing` rather than an invented
-        // error: the board says the machine went quiet, which is true.
-        await postAgentTurn({ turnId, outcome: 'nothing' });
+        // No worktree and none could be cut. `nothing`, WITH git's own words:
+        // without them the agent sat in Stuck with no question and no reason
+        // (the owner, 2026-09-25: "it got stuck without saying why").
+        const why = placeWtFor.lastError ?? null;
+        await postAgentTurn({ turnId, outcome: 'nothing', ...(why ? { answer: `This machine could not start the turn: ${why}` } : {}) });
         return;
       }
       const wt = dir.wt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.102.0",
+  "version": "0.103.0",
   "description": "Run your own coding CLIs as build agents for Flowviant — Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {