flowviant 0.102.2 → 0.103.0

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/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.2",
+  "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": {