flowviant 0.116.0 → 0.124.0

package/bin/lib/workAgentPlans.mjs

@@ -1,18 +1,21 @@
 /** Agent plan claims, read-only planning turns, and proposal reports. */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { FLEET_URL, FLEET_TOKEN, USER_AGENT, DAEMON_INSTANCE } from './config.mjs';
-import { git, isSafePathSegment } from './git.mjs';
+import { discoveryGuide } from './discoveryContract.mjs';
+import { compareRepositoryBaselines, measureRepositoryBaseline, repositoryBaselineOf } from './repositoryBaseline.mjs';
+import { knowledgeDirFor } from './knowledgeFiles.mjs';
+import { createToolLog } from './workToolLog.mjs';
+import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
+import { measureAgentFootprint, liveAgentContext } from './agentFootprint.mjs';
 import { parseProposal } from './agentPlan.mjs';
 import { c, note } from './ui.mjs';
 import { runTurn as defaultRunTurn } from './runTurn.mjs';
-import { SYSTEM_PLAN, AGENT_PLAN_KICKOFF } from './prompts.mjs';
+import { SYSTEM_PLAN, AGENT_PLAN_KICKOFF, withProjectContext, REPOSITORY_BASELINE_PARAGRAPH } from './prompts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
-import { RUNTIMES, canRun } from './runtimes.mjs';
+import { canRun, runtimeById, runtimeLabel } from './runtimes.mjs';
 import { detectRuntimes as defaultDetectRuntimes, pickRuntimeFor as defaultPickRuntimeFor } from './runtimeDetection.mjs';
 import { brainFor } from './workBrain.mjs';
-import { removeProbeTranscript } from './runtimeCapabilities.mjs';
+import { runCappedTurn } from './workCappedTurn.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
+import { claimFleetLease, fleetHeaders } from './fleetPost.mjs';
 import { REPO_PLACE } from './workPlaces.mjs';
 import { addUsage } from './turnUsage.mjs';
 
@@ -43,8 +46,11 @@ export function createWorkAgentPlans({
   // creates a worktree, a branch or a card.
   //
   // READ-ONLY IN THE CHECKOUT. `profile: 'consult'` selects `consultPermFor` (the
-  // fenced Read/Glob rules plus a few path-validated `git`/`ls`/`cat` reads —
-  // no Write, no Edit, no mkdir, no rm) and NO MCP is passed at all, so this
+  // fenced Read/Glob rules plus a few shell readers: `ls`/`cat`/`head`, which
+  // the CLI path-validates itself, and the `git` readers, which it does not —
+  // their path fence is the read guard's refusal (hooks/readGuard.mjs), of
+  // `--no-index` and of any git argument aimed off the checkout — and no
+  // Write, no Edit, no mkdir, no rm) and NO MCP is passed at all, so this
   // turn has no control plane to reach even if the repository it reads tries
   // to steer it. The proposal comes back as the turn's final message rather
   // than through a tool, which is exactly what lets that permission set be
@@ -68,8 +74,8 @@ export function createWorkAgentPlans({
    * on a PRESS instead of an agent.
    *
    * This turn was already streaming and the daemon was already reading it:
-   * `streamJson` humanizes every read, grep, command and thought and prints
-   * it behind `[plan]` on the operator's terminal. Every one of those lines
+   * runTurn's event reader humanizes every read, grep, command and thought
+   * and prints it behind `[plan]` on the operator's terminal. Every one of those lines
    * was then thrown away, so a Deploy press said "planning" on the board and
    * nothing else for as long as it took — which on an overnight queue is the
    * whole night. Forwarding the CLI's own tail costs nothing that is not
@@ -90,11 +96,7 @@ export function createWorkAgentPlans({
     try {
       await fetch(AGENT_PLAN_ACTIVITY_URL, {
         method: 'POST',
-        headers: {
-          Authorization: `Bearer ${FLEET_TOKEN}`,
-          'User-Agent': USER_AGENT,
-          'Content-Type': 'application/json',
-        },
+        headers: fleetHeaders(),
         signal: AbortSignal.timeout(15_000),
         body: JSON.stringify({ planId, line: text }),
       });
@@ -131,78 +133,8 @@ export function createWorkAgentPlans({
    */
   const PLAN_TURN_TIMEOUT_MS = 15 * 60_000;
 
-  const claimAgentPlan = async (id) => {
-    try {
-      const res = await fetch(AGENT_PLAN_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; // the peer may hold it; doing nothing is the safe answer
-    }
-  };
-
-  /**
-   * What a live agent has already TOUCHED, measured here rather than sent.
-   *
-   * The server could have shipped a copy of this, and deliberately does not:
-   * these are directories on THIS machine, and a server-side copy would be a
-   * second, staler source of truth for a fact the daemon is standing on top of.
-   *
-   * Uncommitted work AND commits against base, because a planner asking "will
-   * these collide" cares about both — a file this agent has already rewritten
-   * and merged into its own branch collides exactly as hard as one it is
-   * editing now.
-   */
-  const agentChangedFiles = (placeId) => {
-    if (!placeId || !isSafePathSegment(placeId)) return [];
-    const wt = join(baseDir, 'sessions', placeId);
-    if (!existsSync(wt)) return [];
-    const out = new Set();
-    for (const args of [
-      ['diff', '--name-only', 'HEAD'],
-      ['diff', '--name-only', `${baseRef()}...HEAD`],
-      ['ls-files', '--others', '--exclude-standard'],
-    ]) {
-      /**
-       * `git()` THROWS; it does not return a non-string.
-       *
-       * The guard below was `if (typeof r !== 'string') continue`, which is a
-       * value `execFileSync` can never produce — so every one of these calls
-       * was effectively unguarded. And this runs over the LIVE AGENTS a plan
-       * job carries, which include agents still in `planning`: they have no
-       * worktree yet, so `git diff` in a directory that does not exist exits
-       * non-zero and throws straight out of `runAgentPlan` — after the press
-       * has been claimed and before the try/finally below. The press then sat
-       * `planning` until its expiry, having spent nothing and explained
-       * nothing, on what would be an ordinary second Deploy.
-       *
-       * An agent whose files cannot be read contributes none. That is the
-       * honest answer and it is what the planner should be told.
-       */
-      let r;
-      try {
-        r = git(args, wt);
-      } catch {
-        continue;
-      }
-      if (typeof r !== 'string') continue;
-      for (const line of r.split('\n')) {
-        const f = line.trim();
-        if (f) out.add(f);
-        if (out.size >= 60) return [...out];
-      }
-    }
-    return [...out];
-  };
+  // The peer may hold it; doing nothing is the safe answer.
+  const claimAgentPlan = (id) => claimFleetLease(AGENT_PLAN_CLAIM_URL, { id });
 
   /** See `runAgentTurn` — the admission reservation, released the moment the
    *  planner's CLI exists. */
@@ -238,16 +170,17 @@ export function createWorkAgentPlans({
       : job.model != null || job.effort != null ? 'claude' : null;
     if (pickedRuntime) {
       rt = pickedRuntime;
-      if (!Object.hasOwn(RUNTIMES, rt)) {
+      const runtime = runtimeById(rt);
+      if (!runtime) {
         await postAgentPlan({ id, error: `${rt} is not a CLI this machine knows` });
         return;
       }
-      const label = RUNTIMES[rt].label;
+      const label = runtime.label;
       if (!detectRuntimes().find((r) => r.id === rt)?.installed) {
         await postAgentPlan({ id, error: `${label} is not installed on this machine` });
         return;
       }
-      if (!canRun(RUNTIMES[rt], 'consult')) {
+      if (!canRun(runtime, 'consult')) {
         await postAgentPlan({ id, error: `${label} can't run a read-only turn on this machine` });
         return;
       }
@@ -288,39 +221,8 @@ export function createWorkAgentPlans({
       lastPlanBeat = Date.now();
       void postAgentPlanActivity(id, line);
     };
-    const liveAgents = (Array.isArray(job.liveAgents) ? job.liveAgents : []).map((a) => ({
-      id: String(a?.id ?? ''),
-      name: String(a?.name ?? ''),
-      status: String(a?.status ?? ''),
-      // Belt: `agentChangedFiles` is defensive internally, but it resolves a
-      // place first and this whole block sits outside the try below.
-      changedFiles: (() => {
-        try {
-          return agentChangedFiles(a?.placeId);
-        } catch {
-          return [];
-        }
-      })(),
-    }));
 
     let out = '';
-    /** REMOVED IN A `finally`. `workChildren` is what `workBusy()` counts, and
-     *  a leaked entry keeps the daemon permanently "busy" — which blocks every
-     *  auto-update from that moment on, silently, until a restart. */
-    let planChild = null;
-    let planTimer = null;
-    /**
-     * THE PLANNER'S OWN CONVERSATION, so its transcript can be removed.
-     *
-     * `claude -p` in the CHECKOUT writes `~/.claude/projects/<checkout>/<id>.jsonl`,
-     * and the checkout is exactly where the operator runs their own terminal
-     * Claude. Left behind, every Deploy press became the newest ENDED session
-     * there: it displaced the operator's real conversation from the `+` adopt
-     * menu (one row per directory), offered to fork a read-only planner into a
-     * build tab, and was what their own `claude --continue` resumed. The
-     * pre-review and the skills probe delete theirs for the same reason.
-     */
-    let planSession = null;
     /** The cap fired: the CLI was still running when this machine stopped it. */
     let wedged = false;
     /**
@@ -331,7 +233,8 @@ export function createWorkAgentPlans({
      * a report the retry posts again adds nothing. Null until the CLI reports.
      */
     let usage = null;
-    const spent = () => (usage ? { usage } : {});
+    const discovery = createToolLog(repoRoot);
+    const spent = () => ({ ...(usage ? { usage } : {}), tools: discovery.toolLog });
     // Said BEFORE the lock is asked for, because a reader only waits when a
     // writer holds the checkout or is queued ahead of it — which is exactly
     // this condition, read one line before we join the queue.
@@ -341,92 +244,72 @@ export function createWorkAgentPlans({
     try {
       await inPlace(REPO_PLACE, false, async () => {
         /**
-         * THE CAP RESOLVES THE WAIT ITSELF rather than waiting for `close`
-         * after the kill — the shape the project check's timeout already
-         * keeps. A SIGKILLed process whose stdio a grandchild still holds can
-         * be slow to emit `close`, or never emit it, and this promise is what
-         * holds the claimed press open.
+         * ONE CAPPED CONSULT TURN (workCappedTurn.mjs): the child registered
+         * in `workChildren` and removed on every exit, the reservation
+         * released at the spawn, the cap ARMED AT THE SPAWN — time spent
+         * waiting for the checkout is not a wedged CLI, and a press that never
+         * got to run is what the server's own clock is for — and the
+         * planner's transcript removed from the CHECKOUT, where it would
+         * otherwise become the newest ENDED session: displacing the
+         * operator's real conversation from the `+` adopt menu, offering to
+         * fork a read-only planner into a build tab, and being what their own
+         * `claude --continue` resumed.
          */
-        let stopWaiting = () => {};
-        const capped = new Promise((r) => {
-          stopWaiting = r;
-        });
-        const turn = runTurn({
-          prompt: AGENT_PLAN_KICKOFF({
-            tasks,
-            liveAgents,
-            agentCap: Number.isInteger(job.agentCap) && job.agentCap > 0 ? job.agentCap : 3,
-          }),
-          system: SYSTEM_PLAN,
-          // READ-ONLY, and no MCP: `mcpArgs` is omitted entirely rather than
-          // passed empty, so there is no control plane on this turn at all.
-          profile: 'consult',
-          cwd: repoRoot,
-          runtime: rt,
-          ...brainFor(job, rt),
-          streamJson: true,
-          answerFromResult: true,
-          label: c.cyan('[plan]'),
-          // The CLI's own tail, forwarded to the press. Same rule as an agent
-          // turn's: throttled, overwritten rather than appended, and never
-          // awaited by the turn.
-          onActivity: (a) => {
-            if (a?.label) narrate(String(a.label));
-          },
-          onInit: (i) => {
-            if (typeof i.sessionId === 'string' && i.sessionId.trim())
-              planSession = i.sessionId.trim();
-          },
-          // Tagged with the CLI that counted it; one turn, so the sum is the
-          // one report (turnUsage.mjs keeps it null-safe).
-          onUsage: (u) => {
-            usage = addUsage(usage, { ...u, runtime: rt });
+        const liveAgents = (Array.isArray(job.liveAgents) ? job.liveAgents : []).map(a =>
+          liveAgentContext(a, measureAgentFootprint({ placeId: a?.placeId, baseDir, baseRef })));
+        const knowledgeDir = knowledgeDirFor(repoRoot);
+        discovery.toolLog.baseline = measureRepositoryBaseline({ cwd: repoRoot, baseRef, knowledgeDir });
+        discovery.toolLog.captureBaseline = repositoryBaselineOf(job.captureBaseline);
+        discovery.toolLog.reconciliation = compareRepositoryBaselines(discovery.toolLog.baseline, discovery.toolLog.captureBaseline);
+        ({ out, wedged } = await runCappedTurn({
+          runTurn,
+          capMs: PLAN_TURN_TIMEOUT_MS,
+          workChildren,
+          releaseSlot,
+          transcriptCwd: repoRoot,
+          turnArgs: {
+            diagnosticPlanId: id,
+            prompt: AGENT_PLAN_KICKOFF({
+              tasks,
+              liveAgents,
+              agentCap: Number.isInteger(job.agentCap) && job.agentCap > 0 ? job.agentCap : 3,
+            }),
+            system: withProjectContext(SYSTEM_PLAN, { knowledgeDir }) + '\n\n' + discoveryGuide(rt, 'planning') + '\n\n' + REPOSITORY_BASELINE_PARAGRAPH(discovery.toolLog.baseline, discovery.toolLog.captureBaseline, discovery.toolLog.reconciliation),
+            knowledgeDir,
+            // READ-ONLY, and no MCP: `mcpArgs` is omitted entirely rather than
+            // passed empty, so there is no control plane on this turn at all.
+            profile: 'consult',
+            cwd: repoRoot,
+            runtime: rt,
+            ...brainFor(job, rt),
+            answerFromResult: true,
+            label: c.cyan('[plan]'),
+            // The CLI's own tail, forwarded to the press. Same rule as an agent
+            // turn's: throttled, overwritten rather than appended, and never
+            // awaited by the turn.
+            onActivity: (a) => {
+              if (a?.label) narrate(String(a.label));
+            },
+            onToolEvent: discovery.pushToolEvent,
+            // Tagged with the CLI that counted it; one turn, so the sum is the
+            // one report (turnUsage.mjs keeps it null-safe).
+            onUsage: (u) => {
+              usage = addUsage(usage, { ...u, runtime: rt });
+            },
           },
-          onSpawn: (ch) => {
-            planChild = ch;
-            // No id: a Deploy press is not a task, and the snapshot's per-task
-            // rows must not invent one. It still COUNTS against the machine's
-            // ceiling — see liveTurnCount.
-            workChildren.set(ch, null);
-            releaseSlot();
-            say(`${RUNTIMES[rt]?.label ?? rt} started on this machine`);
-            /**
-             * ARMED AT THE SPAWN, not at the claim: time spent waiting for the
-             * checkout is not a wedged CLI, and a press that never got to run
-             * is what the server's own clock is for.
-             *
-             * The CHILD, never its group — the rule teardown keeps. A
-             * read-only planning turn starts no dev server, so there is
-             * nothing behind it worth signalling and everything to lose by
-             * signalling somebody else's.
-             */
-            planTimer = setTimeout(() => {
-              wedged = true;
-              try {
-                ch.kill('SIGKILL');
-              } catch {
-                /* already gone */
-              }
-              stopWaiting('');
-            }, PLAN_TURN_TIMEOUT_MS);
-            planTimer.unref?.();
+          onSpawn: () => {
+            say(`${runtimeLabel(rt)} started on this machine`);
           },
-        });
-        out = await Promise.race([turn, capped]);
+        }));
       });
     } catch (e) {
+      discovery.toolLog.state = 'partial';
       await postAgentPlan({ id, error: envScrub(String(e?.message || e)).slice(0, 500), ...spent() });
       return;
-    } finally {
-      if (planTimer) clearTimeout(planTimer);
-      if (planChild) workChildren.delete(planChild);
-      // On EVERY exit, after the kill and on a delay — the transcript is the
-      // child's file, and removing it while the child is still dying races a
-      // recreate. The pre-review's own shape.
-      if (planSession) setTimeout(() => removeProbeTranscript(repoRoot, planSession), 750).unref?.();
     }
 
     if (wedged) {
+      discovery.toolLog.state = 'partial';
       // NEVER LEAVE A CLAIMED PRESS UNREPORTED — the belt the merge lane wears
       // beneath this one. The machine's own words, because the machine is the
       // only side that knows: the server would have expired this press in