flowviant 0.40.1 → 0.43.0

package/bin/lib/live.mjs

@@ -43,7 +43,7 @@ import {
   restoreWip,
   clearWip,
 } from './git.mjs';
-import { applyPatch, fileDiffs, ownerCurrentBranch, withPatchLock } from './patch.mjs';
+import { applyPatch, commitHistory, fileDiffs, ownerCurrentBranch, withPatchLock } from './patch.mjs';
 import { RUNTIMES, runtimeById, drivableHere, mediated } from './runtimes.mjs';
 import { loadPreviewConfig, startPreview } from './preview.mjs';
 import { materializeInto, scrub as envScrub } from './env.mjs';
@@ -88,7 +88,7 @@ async function registerLiveTarget(intentId, kind, url) {
         'Content-Type': 'application/json',
       },
       signal: AbortSignal.timeout(30_000),
-      body: JSON.stringify({ intentId, kind, url, ttlMinutes: PREVIEW_TTL_MINUTES }),
+      body: JSON.stringify({ taskId: intentId, kind, url, ttlMinutes: PREVIEW_TTL_MINUTES }),
     });
   } catch {
     /* best-effort — the tunnel still works; it just isn't linked in the app */
@@ -108,7 +108,7 @@ function clearLiveTarget(intentId, kind) {
       'Content-Type': 'application/json',
     },
     signal: AbortSignal.timeout(5_000),
-    body: JSON.stringify({ intentId, kind }),
+    body: JSON.stringify({ taskId: intentId, kind }),
   }).catch(() => {});
 }
 
@@ -127,7 +127,7 @@ function postPreviewNote(intentId, text) {
     signal: AbortSignal.timeout(10_000),
     // Scrub: preview failure reasons can quote dev-server output, which can
     // echo env values.
-    body: JSON.stringify({ intentId, text: envScrub(text) }),
+    body: JSON.stringify({ taskId: intentId, text: envScrub(text) }),
   }).catch(() => {});
 }
 
@@ -316,6 +316,33 @@ function seedPrompt(runId, brief, transcript, resumedInPlace) {
 // The flowviant MCP endpoint handles tools/call statelessly with a bearer
 // worker token — no handshake — so this is all the daemon needs.
 let rpcId = 0;
+/**
+ * Push this task's commits + real diffs to the control plane.
+ *
+ * The server used to fetch exactly this from github.com with a GitHub App
+ * installation token — the app existed largely for it. We are standing in the
+ * worktree that produced these commits, so we send them: the thread's diff
+ * timeline, the review quiz and the merge gate's approved-head pin all read
+ * what lands here.
+ *
+ * Best-effort by design. A failure here must never fail the run — the work is
+ * committed and the PR is open either way, and the next push reports again.
+ * What it costs when it does fail is visible rather than silent: the thread
+ * shows no diffs, which is the same thing it showed when GitHub was unreachable.
+ */
+async function reportCommits({ mcpUrl, token, runId, cwd, baseRef }) {
+  try {
+    const base = baseRef ?? 'HEAD';
+    const commits = commitHistory(cwd, base);
+    if (commits.length === 0) return;
+    const headSha = commits[commits.length - 1].sha;
+    const res = await mcpCall(mcpUrl, token, 'report_commits', { runId, headSha, commits });
+    if (res?.ok === false) warn(`report_commits rejected: ${res.reason ?? 'unknown'}`);
+  } catch (e) {
+    warn(`report_commits skipped: ${e?.message ?? String(e)}`);
+  }
+}
+
 async function mcpCall(mcpUrl, token, name, args) {
   const res = await fetch(mcpUrl, {
     method: 'POST',
@@ -1023,6 +1050,7 @@ async function driveMediated({
             ...(result.branch ? { branch: String(result.branch) } : {}),
           }).catch((e) => ({ ok: false, reason: e?.message ?? String(e) }));
           if (attached?.ok === false) warn(`attach_pr rejected: ${attached.reason ?? 'unknown'}`);
+          else await reportCommits({ mcpUrl, token, runId, cwd, baseRef });
         }
       }
       clearTaskMarker(cwd);
@@ -1274,7 +1302,13 @@ export async function runLiveTask({
     runtimes: DRIVABLE_HERE,
   }).catch(() => null);
   if (!claim || claim.claimed !== true) return { outcome: 'nothing' };
-  const { runId, intentId } = claim;
+  const runId = claim.runId;
+  // New name first: the server returns `taskId` natively and mirrors
+  // `intentId` beside it for exactly this read. Reading taskId is what lets
+  // that mirror (and the fleet routes' intentId compat) retire once
+  // daemon:min passes this release. The variable keeps the old spelling —
+  // it is the daemon's internal word, not a wire field.
+  const intentId = claim.taskId ?? claim.intentId;
   const brief = claim.brief ?? {};
   const title = brief.title ?? 'a task';
 

package/bin/lib/patch.mjs

@@ -125,12 +125,15 @@ const DIFF_STATUS = { A: 'added', D: 'removed', M: 'modified' };
  * pass back to `git diff -- <path>`. A rename showing up as a delete plus an add
  * is a slightly longer diff and a correct one.
  */
-export function fileDiffs(cwd, base) {
+export function fileDiffs(cwd, base, { range, maxFiles = MAX_DIFF_FILES } = {}) {
+  // `range` lets the per-COMMIT walk reuse this (`sha^..sha`); without it the
+  // original meaning holds — everything the agent did since `base`.
+  const rev = range ?? `${base}..HEAD`;
   let numstat = '';
   let names = '';
   try {
-    numstat = git(['diff', '--numstat', '--no-renames', `${base}..HEAD`], cwd);
-    names = git(['diff', '--name-status', '--no-renames', `${base}..HEAD`], cwd);
+    numstat = git(['diff', '--numstat', '--no-renames', rev], cwd);
+    names = git(['diff', '--name-status', '--no-renames', rev], cwd);
   } catch {
     return [];
   }
@@ -144,7 +147,7 @@ export function fileDiffs(cwd, base) {
 
   const out = [];
   for (const line of numstat.split('\n')) {
-    if (out.length >= MAX_DIFF_FILES) break;
+    if (out.length >= maxFiles) break;
     const m = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line.replace(/\n$/, ''));
     if (!m) continue;
     const path = m[3].trim();
@@ -154,7 +157,7 @@ export function fileDiffs(cwd, base) {
     let patch = null;
     if (!binary) {
       try {
-        const full = git(['diff', `${base}..HEAD`, '--', path], cwd);
+        const full = git(['diff', rev, '--', path], cwd);
         // Drop git's own "diff --git a/… b/…" preamble; the card shows the path.
         const at = full.indexOf('@@');
         const hunks = at === -1 ? full : full.slice(at);
@@ -293,3 +296,68 @@ export function revertPatch({ repoRoot, shas }) {
     return { ok: false, error: e?.message ?? String(e) };
   }
 }
+
+
+// How many commits of a task's branch we carry across. The server used to read
+// this from GitHub and capped at 50 for the same reason: each commit costs a
+// diff, and a runaway branch must not fan out unbounded work or produce a row
+// too big to read on every card render. Truncation keeps the MOST RECENT
+// commits — the tail is what a reviewer is looking at.
+const MAX_COMMITS = 50;
+
+/**
+ * A task branch's commits with their real per-file diffs, in the exact shape
+ * the server's GitHub read used to return (`TaskCommit[]`).
+ *
+ * This is the function that let the GitHub App die. The server used to resolve
+ * the project's linked repo, mint an installation token, fetch
+ * `GET /pulls/{n}/commits` and then run an N+1 of `GET /commits/{sha}` for the
+ * per-file patches — up to ~52 API calls to describe work THIS process had just
+ * performed, in a checkout it is standing in. Now the daemon reports it through
+ * `report_commits` and the server reads a row.
+ *
+ * Oldest → newest, because the thread appends chronologically.
+ */
+export function commitHistory(cwd, base) {
+  let log = '';
+  try {
+    // %x1f/%x1e are unit/record separators: a commit subject can contain
+    // anything, tabs and pipes included, so the delimiters have to be bytes a
+    // human will never type.
+    log = git(
+      ['log', '--reverse', `--max-count=${MAX_COMMITS}`, '--format=%H%x1f%s%x1f%an%x1f%aI%x1e', `${base}..HEAD`],
+      cwd,
+    );
+  } catch {
+    return [];
+  }
+
+  const out = [];
+  for (const record of log.split('\x1e')) {
+    const line = record.trim();
+    if (!line) continue;
+    const [sha, message, authorName, committedAt] = line.split('\x1f');
+    if (!sha) continue;
+    // First-parent range for the commit itself. A root commit has no `^`, in
+    // which case git's empty-tree hash gives us the whole thing as an add.
+    let range = `${sha}^..${sha}`;
+    try {
+      git(['rev-parse', `${sha}^`], cwd);
+    } catch {
+      range = `4b825dc642cb6eb9a060e54bf8d69288fbee4904..${sha}`;
+    }
+    const files = fileDiffs(cwd, null, { range });
+    out.push({
+      sha,
+      message: (message ?? '').slice(0, 500),
+      authorName: (authorName ?? '').slice(0, 200),
+      authorLogin: null,
+      committedAt: committedAt ?? new Date().toISOString(),
+      url: null,
+      additions: files.reduce((n, f) => n + f.additions, 0),
+      deletions: files.reduce((n, f) => n + f.deletions, 0),
+      files,
+    });
+  }
+  return out;
+}

package/bin/lib/resources.mjs

@@ -121,7 +121,7 @@ export function machineSnapshot({ worktreeDir, tasks = [] } = {}) {
     diskTotal: disk?.total ?? null,
     // Per-task, so "the box is full" can be traced to the task that filled it.
     tasks: tasks
-      .map((t) => ({ intentId: t.intentId, rss: processTreeRssBytes(t.pid) }))
-      .filter((t) => t.intentId && t.rss),
+      .map((t) => ({ taskId: t.intentId, rss: processTreeRssBytes(t.pid) }))
+      .filter((t) => t.taskId && t.rss),
   };
 }

package/bin/lib/runtimes.mjs

@@ -299,11 +299,11 @@ export const RUNTIMES = {
     live: true,
     /**
      * Every profile, because every profile is DEFINED in its vocabulary: the
-     * three `--allowedTools` lists in claude.mjs are what "build", "wiki" and
-     * "consult" currently mean. That is a statement about where the contract was
-     * written, not a claim that only Claude could ever satisfy it.
+     * four `--allowedTools` lists in claude.mjs are what "build", "wiki",
+     * "consult" and "plan" currently mean. That is a statement about where the
+     * contract was written, not a claim that only Claude could ever satisfy it.
      */
-    profiles: ['build', 'wiki', 'consult'],
+    profiles: ['build', 'wiki', 'consult', 'plan'],
     mcp: claudeMcp,
     /**
      * Claude takes the operating contract as a real system prompt, which is the
@@ -349,7 +349,7 @@ export const RUNTIMES = {
      * and Windows are UNTESTED; if this daemon starts running there, re-verify
      * before trusting the consult posture on those platforms.
      */
-    profiles: ['build', 'consult', 'wiki'],
+    profiles: ['build', 'consult', 'wiki', 'plan'],
     mcp: codexMcp,
     /**
      * Codex has NO system-prompt flag. The contract therefore rides inside the
@@ -418,6 +418,30 @@ export const RUNTIMES = {
         // we are asserting on their behalf — silently, and on the one turn whose
         // prompt comes from someone else's typing.
         a.push('--ignore-user-config', '--ignore-rules');
+      } else if (profile === 'plan') {
+        // A PLANNING SESSION. Read-only on the filesystem, exactly like a
+        // consult — the writes it makes go through the control plane, not
+        // through this box — so the kernel sandbox is the same one, and for the
+        // same reason: this turn's prompt is steered by anything a project
+        // editor can type.
+        //
+        // Everything the consult branch above closes stays closed, and the
+        // reasoning is unchanged, so it is not restated: web_search egresses
+        // server-side at OpenAI where no local sandbox reaches it, sub-agents
+        // would be a turn whose posture nobody here chose, and a user's own
+        // config or MCP servers must not widen a posture we are asserting on
+        // their behalf.
+        //
+        // What differs from a consult is the ONE thing this profile exists for:
+        // an MCP config IS passed, carrying the plan principal's token. That
+        // token's whole tool set is the five plan tools — the server refuses
+        // anything else on it — so the control plane being open here does not
+        // widen what a hijacked turn could reach beyond the plan it is already
+        // sitting in.
+        a.push('--sandbox', 'read-only');
+        a.push('-c', 'tools.web_search=false', '-c', 'web_search="disabled"');
+        a.push('-c', 'features.multi_agent=false', '-c', 'features.goals=false');
+        a.push('--ignore-user-config', '--ignore-rules');
       } else if (profile === 'wiki' && vaultDir) {
         // THE CARTOGRAPHER, AND THIS ONE IS STRICTER THAN CLAUDE'S.
         //
@@ -572,6 +596,17 @@ export const RUNTIMES = {
      * MCP connection and the CLI just returns schema-enforced JSON via
      * `--json-schema`), which needs no per-invocation MCP config from the vendor
      * at all.
+     *
+     * PLAN IS ABSENT ON PURPOSE, and NOT because a planning turn is beyond it —
+     * it reads code as well as anything here. A plan session is a conversation
+     * that makes many control-plane calls as it goes (spawn a slice, re-shape
+     * it, drop it, rewrite the spec), and mediation turns a turn into ONE
+     * schema-enforced form the daemon then applies. That shape fits a build,
+     * whose outcome is a single structured result; it does not yet fit an
+     * argument. Note that `canRun` would otherwise say yes via `mediated()` and
+     * hand this runtime a job it cannot finish — declaring the profile is the
+     * only thing standing between here and that. Mediated planning is a real
+     * design (the session returns its writes as a batch), just not a built one.
      */
     profiles: ['build', 'wiki', 'consult'],
     mcp: null,
@@ -687,7 +722,7 @@ export const runtimeById = (id) => RUNTIMES[id] ?? RUNTIMES.claude;
  * disagree the daemon either claims work it cannot build or refuses work it can.
  */
 /**
- * WHICH PROFILES NEED THE MCP CONTROL PLANE. Only one does.
+ * WHICH PROFILES NEED THE MCP CONTROL PLANE. Two do.
  *
  * A BUILD has to claim work, report a blocker, attach a PR and complete — that
  * is the control plane, and a runtime that cannot reach it cannot participate.
@@ -696,11 +731,17 @@ export const runtimeById = (id) => RUNTIMES[id] ?? RUNTIMES.claude;
  * included — check the two call sites in fleet.mjs, they hand `runTurn` no
  * `mcpArgs` at all.
  *
+ * A PLAN is the second one, and it is the reason the consult stopped being the
+ * whole story: a planning session does not answer a question, it WRITES the plan
+ * — spawns the slices, re-shapes them, drops them, maintains the spec. Every one
+ * of those is a control-plane call, so a runtime that cannot reach MCP cannot
+ * host a session, however well it reads code.
+ *
  * Conflating them cost Antigravity every capability it has: `mcp && args` was
  * the single drivability test, so a machine-wide MCP config disqualified it from
  * two jobs that never open an MCP connection.
  */
-const PROFILE_NEEDS_MCP = { build: true, wiki: false, consult: false };
+const PROFILE_NEEDS_MCP = { build: true, wiki: false, consult: false, plan: true };
 
 /**
  * A build needs the control plane, but NOT necessarily an MCP config of its own.

package/package.json

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