flowviant 0.74.2 → 0.75.0

package/bin/lib/deploy.mjs

@@ -77,6 +77,10 @@ export async function reportDeployConfig(repoRoot) {
     healthcheck: t.healthcheck,
     healthStatus: t.healthStatus,
     pushSecrets: t.pushSecrets,
+    // Deploy-on-merge: the env this target auto-deploys to when commits land
+    // on base. MUST ride this map — a field forgotten here never reaches the
+    // server, and the server is what turns a landed report into the job.
+    ...(typeof t.onMerge === 'string' ? { onMerge: t.onMerge } : {}),
   }));
   try {
     await post('deploy-config', { pubkey: myPubB64(), targets: meta });

package/bin/lib/fleet.mjs

@@ -816,6 +816,7 @@ export async function runFleetDaemon() {
     processShipJobs,
     processDiffJobs,
     processKillJobs,
+    processPrJobs,
     heldSessionIds,
     processPreviewJobs,
     livePreviewIds,
@@ -1610,6 +1611,11 @@ export async function runFleetDaemon() {
     // the pid on this job is a request, never an authority, because pids are
     // recycled and the row the browser clicked is up to a sweep old.
     processKillJobs(roster.killJobs);
+    // PR-mode work (push + open, or merge) — leased like a kill: two daemons
+    // pushing one branch would open two PRs. Runs under the operator's own
+    // `gh` credential; a settle never closes a card (done is observed by the
+    // landed walk when the merge reaches base).
+    processPrJobs(roster.prJobs);
     // …and what the SURVIVING ones hold: branch, ahead-of-base, diffstat.
     // Throttled inside, never awaited — a `git status` the human cannot run
     // themselves from a browser, relayed. After retirement so a directory that

package/bin/lib/landed.mjs

@@ -0,0 +1,175 @@
+/**
+ * THE LANDED OBSERVER — what arrived on base, whichever road it took.
+ *
+ * The daemon already fetches origin on a throttled beat (the worktree sweep)
+ * and moves the local base ref itself on a ship push. This module watches the
+ * base tip across those moments and, when it moves, walks the NEW commits and
+ * reports them to /fleet/base-landed: sha, subject, and any `Flowviant-Task:`
+ * trailer ids. The server closes what those commits name (a trailer from any
+ * live status, a delivered card's receipt sha) — done is OBSERVED, and this is
+ * the observation that covers a hand push, a PR merged on GitHub, and a
+ * teammate's ship, none of which pass through /fleet/ship-done.
+ *
+ * A daemon→server REPORT, so there is no version floor and the delivery
+ * discipline is repo-state's: a 404 (older server) goes quiet until restart,
+ * and the observed tip is persisted ONLY when the server accepted the report —
+ * a failed POST re-walks the same range on the next beat, which is free
+ * because the server skips done cards.
+ *
+ * FIRST SIGHT SEEDS, NEVER WALKS. A fresh install (or a base-ref change) has
+ * no honest "since when", and walking history would close every trailered card
+ * ever merged. The tip is recorded and observation starts from there. The same
+ * rule covers a range the repo can no longer answer (force-push, gc): reseed,
+ * report nothing — ignorance is never turned into a state.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { git, baseBranchName } from './git.mjs';
+import { taskIdsFromMessage } from './worktreeDiff.mjs';
+import { warn } from './ui.mjs';
+import { FLEET_URL, FLEET_TOKEN, USER_AGENT } from './config.mjs';
+
+const LANDED_URL = FLEET_URL.replace(/\/agents\/?$/, '/base-landed');
+/** The server accepts 50 per report. A bigger range walks OLDEST-FIRST in
+ *  batches: the persisted tip advances to the last commit actually reported,
+ *  so the remainder is picked up on the next beat rather than skipped forever
+ *  — a trailered card in commit 51 of a big catch-up still closes. */
+const MAX_COMMITS = 50;
+const SHA_RE = /^[0-9a-f]{7,64}$/i;
+
+export function createLandedObserver({ repoRoot, baseRef }) {
+  // Keyed like the worktree base dir: one state file per checkout, so two
+  // repos on one box never share a tip.
+  const key = createHash('sha256').update(String(repoRoot)).digest('hex').slice(0, 8);
+  const stateFile = join(homedir(), '.flowviant', `landed-${key}.json`);
+  let unsupported = false; // 404 once → an older server; quiet until restart
+  let inFlight = false;
+
+  const readState = () => {
+    try {
+      const s = JSON.parse(readFileSync(stateFile, 'utf8'));
+      return s && typeof s.ref === 'string' && typeof s.tip === 'string' ? s : null;
+    } catch {
+      return null;
+    }
+  };
+  const writeState = (s) => {
+    try {
+      mkdirSync(join(homedir(), '.flowviant'), { recursive: true });
+      writeFileSync(stateFile, JSON.stringify(s));
+    } catch {
+      /* a box that cannot persist just re-observes from the next seed */
+    }
+  };
+
+  const tipOf = (ref) => {
+    try {
+      const t = git(['rev-parse', ref], repoRoot);
+      return SHA_RE.test(t) ? t : null;
+    } catch {
+      return null;
+    }
+  };
+
+  /** New non-merge commits in from..to, OLDEST FIRST. `--no-merges` for the
+   *  same reason branchCommits keeps it: a merge commit describes a range
+   *  rather than doing work, and its constituents are walked as themselves. */
+  const walk = (from, to) => {
+    const raw = git(
+      ['log', '--reverse', '--no-merges', '--format=%H%x1f%s%x1f%B%x1e', `${from}..${to}`],
+      repoRoot
+    );
+    const out = [];
+    for (const rec of raw.split('\x1e')) {
+      const line = rec.replace(/^\n+/, '');
+      if (!line.trim()) continue;
+      const [sha, subject, body] = line.split('\x1f');
+      if (!SHA_RE.test(sha || '')) continue;
+      out.push({
+        sha,
+        subject: String(subject || '').slice(0, 200),
+        taskIds: taskIdsFromMessage(body).slice(0, 8),
+      });
+    }
+    return out;
+  };
+
+  /** Look at the base tip; if it moved, report the range. Call after anything
+   *  that may have moved origin/<base> — the sweep's fetch, a ship's push, a
+   *  PR merge this daemon performed. Never throws, never awaited by a turn. */
+  const observe = async () => {
+    if (unsupported || inFlight) return;
+    const ref = baseRef();
+    if (!ref) return;
+    const tip = tipOf(ref);
+    if (!tip) return;
+    const st = readState();
+    if (!st || st.ref !== ref) {
+      writeState({ ref, tip });
+      return;
+    }
+    if (st.tip === tip) return;
+    let all;
+    try {
+      all = walk(st.tip, ref);
+    } catch {
+      // The old tip is no longer answerable (force-push, gc) — reseed and
+      // report nothing rather than guess at a range.
+      writeState({ ref, tip });
+      return;
+    }
+    // Oldest-first BATCH: a range past the server's cap advances the tip only
+    // to the last commit reported, so the remainder rides the next beat —
+    // nothing is skipped forever. (A range of nothing but merge commits still
+    // reports, tip-only: the tip moving is the fact deploy-on-merge rides.)
+    const commits = all.slice(0, MAX_COMMITS);
+    const reportedTip = all.length > MAX_COMMITS ? commits[commits.length - 1].sha : tip;
+    inFlight = true;
+    try {
+      const res = await fetch(LANDED_URL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${FLEET_TOKEN}`,
+          'User-Agent': USER_AGENT,
+          'Content-Type': 'application/json',
+        },
+        signal: AbortSignal.timeout(20_000),
+        body: JSON.stringify({ base: baseBranchName(ref), tip: reportedTip, commits }),
+      });
+      if (res.status === 404) {
+        unsupported = true;
+        return;
+      }
+      if (res.ok) {
+        // Persist ONLY an accepted report — a 5xx (the server could not close
+        // the cards) or a network failure leaves the tip where it was, so the
+        // next beat re-walks the same range and the close re-runs, idempotently.
+        writeState({ ref, tip: reportedTip });
+        // Deploy-on-merge refusals are computed server-side and would
+        // otherwise vanish — an onMerge:'prod' (or a target with no
+        // commands[env]) must not be quietly inert.
+        const j = await res.json().catch(() => null);
+        for (const r of j?.data?.deployRefused ?? []) {
+          warn(`deploy-on-merge refused for target "${r?.targetId}": ${r?.reason}`);
+        }
+      } else if (res.status >= 400 && res.status < 500) {
+        // A persistent 4xx (deploy skew, a payload this server refuses) would
+        // otherwise re-send the same poison range on every beat forever.
+        // Drop the range — the closes it carried re-run at the next REAL tip
+        // move only if their cards are still open, which is the idempotent
+        // half; the honest cost is stated out loud.
+        writeState({ ref, tip });
+        warn(`base-landed report refused (${res.status}) — skipped ${commits.length} commit(s)`);
+      }
+    } catch {
+      /* offline — the next fetch beat retries */
+    } finally {
+      inFlight = false;
+    }
+  };
+
+  return { observe };
+}

package/bin/lib/prompts.mjs

@@ -237,18 +237,32 @@ MECHANICS OF THIS TAB:
    is their word to say, not yours to infer.
 5. WHEN THEY HAVE TO CHOOSE, HAND THEM THE CHOICES. A real pick between known
    options — not an open question — ends your reply with a fenced block the app
-   renders as buttons; their click composes their answer as the next message:
+   renders as an answer card; picking an option and pressing Submit sends its
+   label as their next message, so every label must read as an answer a person
+   would say out loud:
 
    \`\`\`flowviant-ask
-   {"question": "Which auth flow?", "options": ["Magic link", "Password", "Both"], "multiSelect": false}
+   {"question": "Which auth flow should the preview gate use?",
+    "header": "Auth flow",
+    "options": [
+      {"label": "Cookie + CSP change", "description": "Ships today; needs the frame-src change."},
+      {"label": "Header-based", "description": "No CSP change, but every daemon must upgrade."},
+      "Prototype both"
+    ],
+    "multiSelect": false}
    \`\`\`
 
-   ONE block per reply, and always the LAST thing in it. Two to eight options,
-   each label short enough to sit on a button. multiSelect true only for a
-   genuine check-several-of-these case. NEVER for an open question — ask those
-   in prose, like anyone would. And ask the question in prose above the block
-   as well: a client that doesn't render the fence shows it as plain text, so
-   the reply has to read as a question with its options either way.
+   ONE block per reply, and always the LAST thing in it. Two to eight options.
+   A label IS the answer — a few words, never a comma (multi-select answers
+   arrive as the chosen labels comma-joined, in the order listed); a tradeoff
+   goes in "description", one short sentence, optional. "header" is an optional
+   topic tag, three words at most. Plain-string options still work. Do NOT add
+   an "Other" option — the card offers a free-text path itself. multiSelect
+   true only for a genuine check-several-of-these case. NEVER for an open
+   question — ask those in prose, like anyone would. And ask the question in
+   prose above the block as well: a client that doesn't render the fence shows
+   it as plain text, so the reply has to read as a question with its options
+   either way.
 
 THE LEDGER. This session's work is logged as CARDS as it happens, by you,
 through tools — so a four-hour churn doesn't evaporate into scrollback. The
@@ -369,8 +383,10 @@ MECHANICS OF THIS TAB:
    their word to say, not yours to infer.
 5. WHEN THEY HAVE TO CHOOSE, HAND THEM THE CHOICES. You have no tools here, but
    this one costs none — it is text. A real pick between known options (not an
-   open question) ends your reply with a fenced block the app renders as
-   buttons; their click composes their answer as the next message:
+   open question) ends your reply with a fenced block the app renders as an
+   answer card; picking an option and pressing Submit sends its label as their
+   next message, so every label must read as an answer a person would say out
+   loud:
 
    \`\`\`flowviant-ask
    {"question": "Which auth flow?", "options": ["Magic link", "Password", "Both"], "multiSelect": false}

package/bin/lib/work.mjs

@@ -39,6 +39,7 @@ import {
   MODEL,
 } from './config.mjs';
 import { git, gitRaw, splitNul, baseBranchName, isSafePathSegment } from './git.mjs';
+import { createLandedObserver } from './landed.mjs';
 import { listenersIn, measureListeners, listenersSupported } from './listeners.mjs';
 import { measureProcesses, liveGroups, processesSupported } from './processes.mjs';
 import { mutateRegistry, processAlive, readRegistry } from './procRegistry.mjs';
@@ -139,6 +140,12 @@ export function createWorkManager({
   const PREVIEW_DONE_URL = FLEET_URL.replace(/\/agents\/?$/, '/preview-done');
   const SESSION_COMMANDS_URL = FLEET_URL.replace(/\/agents\/?$/, '/session-commands');
   const ATTACHMENT_URL = FLEET_URL.replace(/\/agents\/?$/, '/attachment');
+  const PR_CLAIM_URL = FLEET_URL.replace(/\/agents\/?$/, '/pr-claim');
+  const PR_DONE_URL = FLEET_URL.replace(/\/agents\/?$/, '/pr-done');
+  // What arrived on base, whichever road it took — observed after every beat
+  // that can move origin/<base>: the sweep's fetch, a ship's push, a PR merge
+  // this daemon performed. See landed.mjs for the seeding and delivery rules.
+  const landed = createLandedObserver({ repoRoot, baseRef });
   const workAnswering = new Set(); // turn ids currently queued/running here
   const workAttempts = new Map(); // turn id -> completed runTurn attempts
   const MAX_WORK_TRIES = 3;
@@ -341,6 +348,10 @@ export function createWorkManager({
       // moved. Without this the Repository block keeps counting a branch the
       // ship just deleted.
       onRepoChanged();
+      // The ship's push moved the local origin/<base> ref — observe now, so
+      // the landed report (and anything trailered a ship carried) lands on
+      // this beat rather than the next 3-minute fetch.
+      void landed.observe().catch(() => {});
     }
     return r;
   };
@@ -764,6 +775,9 @@ export function createWorkManager({
           } catch {
             /* offline, or no remote — the numbers just age */
           }
+          // The fetch may have moved the base tip — walk and report what
+          // landed. Best-effort like everything in this sweep.
+          void landed.observe().catch(() => {});
         }
         const reports = [];
         for (const id of activeIds.slice(0, 20)) {
@@ -1301,6 +1315,253 @@ export function createWorkManager({
     }
   };
 
+  // ── PR-mode jobs (projects.mergeMode === 'pr') ──────────────────────────
+  // 'open' = push the session's branch and open a PR; 'merge' = merge it.
+  // Both under the operator's own `gh` credential from the daemon's inherited
+  // env — the same posture the dispatch-era merge path took, and the same one
+  // claude.mjs documents for turns. LEASED like a kill: two daemons pushing
+  // one branch would open two PRs. NOTHING here closes a card — done is
+  // observed by the landed walk when the merge reaches base.
+  const prWorking = new Set();
+  const ghFirstLine = (e) =>
+    ((e?.stderr?.toString?.() || e?.message || 'failed').split('\n').find((l) => l.trim()) ||
+      'failed')
+      .slice(0, 400);
+  const PR_URL_RE = /^https:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+$/;
+  const claimPr = async (id) => {
+    try {
+      const res = await fetch(PR_CLAIM_URL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${FLEET_TOKEN}`,
+          'User-Agent': USER_AGENT,
+          'Content-Type': 'application/json',
+        },
+        signal: AbortSignal.timeout(15_000),
+        body: JSON.stringify({ id, instance: DAEMON_INSTANCE }),
+      });
+      const j = await res.json().catch(() => null);
+      return j?.data?.claimed === true;
+    } catch {
+      return false; // could not claim → do nothing. The other daemon may have.
+    }
+  };
+  const settlePr = async (body) => {
+    try {
+      await fetch(PR_DONE_URL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${FLEET_TOKEN}`,
+          'User-Agent': USER_AGENT,
+          'Content-Type': 'application/json',
+        },
+        signal: AbortSignal.timeout(20_000),
+        body: JSON.stringify({ ...body, instance: DAEMON_INSTANCE }),
+      });
+    } catch {
+      /* the row expires into an honest no_answer; the re-request is the retry */
+    }
+  };
+  const runPrJob = async (job) => {
+    const id = String(job.id);
+    if (!(await claimPr(id))) return;
+    // gh present and authenticated, or the honest 'unsupported' — its own
+    // outcome because "the machine cannot do this at all" and "GitHub said
+    // no" read differently to the person who asked.
+    try {
+      execFileSync('gh', ['auth', 'status'], { stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (e) {
+      const missing = e?.code === 'ENOENT';
+      await settlePr({
+        id,
+        outcome: 'unsupported',
+        detail: missing
+          ? 'the GitHub CLI (gh) is not installed on this machine'
+          : 'gh is not authenticated on this machine — run `gh auth login` there',
+      });
+      return;
+    }
+    // The branch is whatever the session's own worktree HEAD says — the same
+    // resolution ship uses, for the same reason (the branch is where the
+    // driver left it, not where we put it).
+    const sessionId = String(job.sessionId);
+    const place = placeOf(sessionId);
+    const wt = place === REPO_PLACE ? repoRoot : join(baseDir, 'sessions', place);
+    let branch = `session/${sessionId}`;
+    let detached = false;
+    if (existsSync(wt)) {
+      try {
+        branch = git(['symbolic-ref', '--short', 'HEAD'], wt);
+      } catch {
+        detached = true;
+      }
+    }
+    if (detached) {
+      await settlePr({
+        id,
+        outcome: 'failed',
+        detail: 'the session is on a detached HEAD — no branch to push',
+      });
+      return;
+    }
+    // NEVER the base branch. A checkout-place tab (the operator's, at N=1)
+    // commonly stands on base, and pushing it would BE the direct push this
+    // mode exists to replace — on an unprotected repo the work lands with no
+    // PR and the observer closes the cards as landed, PR mode silently
+    // defeated by its own open job.
+    const baseName = baseBranchName(baseRef());
+    if (branch === baseName) {
+      await settlePr({
+        id,
+        outcome: 'failed',
+        detail: `the session is on the base branch (${baseName}) — nothing to open a pull request from; work on a branch first`,
+      });
+      return;
+    }
+    const pushCwd = existsSync(wt) ? wt : repoRoot;
+    /** Adopt only an OPEN PR. gh's branch finder falls back to the most recent
+     *  MERGED/CLOSED PR when no open one exists, and adopting a dead PR turns
+     *  every later delivery on a long-lived session branch into a silent
+     *  black hole ('opened'/'merged' over work that never moves). */
+    const openPrUrl = () => {
+      try {
+        const j = JSON.parse(
+          execFileSync('gh', ['pr', 'view', branch, '--json', 'url,state'], {
+            cwd: repoRoot,
+            stdio: ['ignore', 'pipe', 'pipe'],
+          }).toString()
+        );
+        return j?.state === 'OPEN' && typeof j?.url === 'string' ? j.url.trim() : null;
+      } catch {
+        return null; // no PR for the branch at all
+      }
+    };
+    if (job.kind !== 'merge') {
+      // OPEN: push, then create — or adopt a PR already OPEN for the branch
+      // (a re-delivery, or one the driver opened by hand).
+      try {
+        git(['push', '-u', 'origin', branch], pushCwd);
+      } catch (e) {
+        await settlePr({ id, outcome: 'failed', detail: ghFirstLine(e) });
+        return;
+      }
+      let url = openPrUrl();
+      if (!url) {
+        try {
+          const out = execFileSync(
+            'gh',
+            // `--fill` titles the PR from the branch's own commits — no model
+            // call, nothing invented. baseBranchName, not baseRef: gh 422s on
+            // a remote-tracking name like origin/main.
+            ['pr', 'create', '--head', branch, '--base', baseName, '--fill'],
+            { cwd: repoRoot, stdio: ['ignore', 'pipe', 'pipe'] }
+          )
+            .toString()
+            .trim();
+          url = out.split('\n').filter(Boolean).pop() ?? null;
+        } catch (e) {
+          await settlePr({ id, outcome: 'failed', detail: ghFirstLine(e) });
+          return;
+        }
+      }
+      await settlePr({
+        id,
+        outcome: 'opened',
+        ...(url && PR_URL_RE.test(url) ? { prUrl: url } : {}),
+      });
+      return;
+    }
+    // MERGE: push FIRST — GitHub merges the REMOTE PR tip, and the quiz the
+    // reviewer just passed fingerprinted the LOCAL worktree, so merging
+    // without a push would land a stale tip while the observer closed the
+    // cards over commits that never reached base. Then a MERGE COMMIT, never
+    // squash and never rebase — the cards' receipts are commit shas, and a
+    // squash rewrites them off base, which would orphan every receipt AND
+    // blind the landed walk's trailer read.
+    // No --delete-branch: the local branch may be a live worktree's HEAD.
+    try {
+      git(['push', 'origin', branch], pushCwd);
+    } catch (e) {
+      await settlePr({ id, outcome: 'failed', detail: ghFirstLine(e) });
+      return;
+    }
+    try {
+      execFileSync('gh', ['pr', 'merge', branch, '--merge'], {
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      const line = ghFirstLine(e);
+      if (!/already merged/i.test(line)) {
+        await settlePr({ id, outcome: 'failed', detail: line });
+        return;
+      }
+    }
+    // VERIFY before settling 'merged': modern gh exits 0 on an
+    // already-MERGED PR, so a dead PR from an earlier delivery reads as
+    // success while this branch's newest commits sit unmerged. The branch
+    // tip being an ancestor of base is the fact 'merged' claims — check it,
+    // with one short retry for the fetch racing GitHub's merge commit.
+    const tipSha = (() => {
+      try {
+        return git(['rev-parse', branch], pushCwd);
+      } catch {
+        return null;
+      }
+    })();
+    const tipOnBase = () => {
+      if (!tipSha) return false;
+      try {
+        git(['merge-base', '--is-ancestor', tipSha, baseRef()], repoRoot);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    let merged = false;
+    for (let attempt = 0; attempt < 2 && !merged; attempt++) {
+      if (attempt > 0) await new Promise((r) => setTimeout(r, 2000));
+      try {
+        git(['fetch', 'origin', '--quiet'], repoRoot);
+      } catch {
+        /* offline — the check below answers from what we have */
+      }
+      merged = tipOnBase();
+    }
+    if (!merged) {
+      await settlePr({
+        id,
+        outcome: 'failed',
+        detail:
+          'GitHub reports a merge, but this branch\'s newest commits are not on the base branch — the PR that merged was an older one. Deliver again to open a fresh pull request.',
+      });
+      return;
+    }
+    await settlePr({ id, outcome: 'merged' });
+    // The merge moved base. Observe NOW, so the cards close on this beat
+    // rather than the next 3-minute sweep — the same re-measure-after-an-
+    // action rule the kill and ship paths keep. (The fetch already ran in
+    // the verify loop above.)
+    void landed.observe().catch(() => {});
+    onRepoChanged();
+  };
+  const processPrJobs = (jobs) => {
+    if (!Array.isArray(jobs) || jobs.length === 0) return;
+    for (const job of jobs.slice(0, 5)) {
+      const id = String(job?.id || '');
+      const sid = String(job?.sessionId || '');
+      if (!id || !isSafePathSegment(sid)) continue;
+      // Keyed by SESSION, not job id: a deliver-time open and an approve-time
+      // merge for one session must run in order (the roster offers them FIFO;
+      // running them concurrently would merge before the push-and-create).
+      if (prWorking.has(sid)) continue;
+      prWorking.add(sid);
+      void runPrJob(job)
+        .catch(() => {})
+        .finally(() => prWorking.delete(sid));
+    }
+  };
+
   const processDiffJobs = (jobs) => {
     if (!Array.isArray(jobs) || jobs.length === 0) return;
     for (const job of jobs.slice(0, 5)) {
@@ -3129,6 +3390,7 @@ export function createWorkManager({
     processShipJobs,
     processDiffJobs,
     processKillJobs,
+    processPrJobs,
     heldSessionIds,
     processPreviewJobs,
     livePreviewIds,

package/bin/lib/worktreeDiff.mjs

@@ -55,7 +55,7 @@ const MAX_COMMITS = 50;
  * a plausible id is dropped here rather than shipped: the server drops unknown
  * ids too, but a readout should not spend a request on obvious noise.
  */
-function taskIdsFromMessage(body) {
+export function taskIdsFromMessage(body) {
   const ids = [];
   for (const line of String(body || '').split('\n')) {
     const m = line.match(/^\s*Flowviant-Task\s*:\s*(.+?)\s*$/i);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.74.2",
+  "version": "0.75.0",
   "description": "Run your own coding CLIs as build agents for Flowviant \u2014 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": {