flowviant 0.124.0 → 0.124.1

package/bin/lib/workAgentReview.mjs

@@ -27,17 +27,19 @@ export function createWorkAgentReview({ runCheck, runPrecheck }) {
    * INSIDE the place's writer lock on a path whose callers settle real work —
    * `runAgentMerge` in particular reports a claimed merge after this returns.
    */
-  const runReviewEntry = async (agentId, wt, agentName) => {
+  const runReviewEntry = async (agentId, wt, agentName, repository) => {
+    let result = { status: 'unknown' };
     try {
-      await runCheck(agentId, wt);
+      result = await runCheck(agentId, wt, repository) ?? result;
     } catch {
       /* the row keeps its previous check answer, which is null the first time */
     }
     try {
-      await runPrecheck(agentId, wt, agentName);
+      await runPrecheck(agentId, wt, agentName, repository);
     } catch {
       /* no pre-review is posted, and absence renders nothing */
     }
+    return result;
   };
 
   return { runReviewEntry };

package/bin/lib/workAgentTurnBegun.mjs

@@ -40,11 +40,11 @@ import { worktreePath } from './workPlaces.mjs';
  * cleaned up on THIS box is same-box recovery of real committed work and
  * behaves exactly as it did before this guard existed.
  *
- * The remedy is the stop path and nothing else. "Reconnect the other
- * machine" is not reachable from here once holdership has moved, and a
- * remedy somebody cannot carry out is worse than none.
+ * This remains the same-box and older-server refusal. The recovery coordinator
+ * now inspects foreign work before this ordinary turn path: after a person's
+ * machine swap it can replace missing work with an explicit start from briefs.
  */
-export function begunTurnRefusal(job, place, { baseDir, repoRoot, fetchPublishedBranch }) {
+export function begunTurnRefusal(job, place, { baseDir, repoRoot, fetchPublishedBranch, onAvailable = () => {} }) {
   // The caller validated `place` (workAgentTurns); an unsafe one would give a
   // null directory AND a null ref below, and the null ref stands the guard
   // down — the same fail-open direction as an unreadable repo.
@@ -105,9 +105,11 @@ export function begunTurnRefusal(job, place, { baseDir, repoRoot, fetchPublished
         (fetched ? ` Its published branch could not be fetched (${fetched.why}).` : '')
       );
     }
+    onAvailable();
     // The branch is here and measured. `placeWtFor`'s attach fallback
     // opens a worktree on it below — the same path a directory somebody
     // cleaned up already takes, on commits this box now genuinely holds.
   }
+  if (hasBranch || (wtDir && existsSync(wtDir))) onAvailable();
   return null;
 }

package/bin/lib/workAgentTurnExecution.mjs

@@ -1,3 +1,4 @@
+import { finishRepositoryDelivery, allResolutionsCommitted } from './repositoryDelivery.mjs';
 /**
  * ONE AGENT TURN, RUN: the worktree, the CLI, and what it left behind.
  *
@@ -38,12 +39,17 @@ import { runTurnResumingOnce } from './resumeLost.mjs';
 import { INTERNAL_WAIT_CONTRACT, runAgentWithInternalWaits } from './agentInternalWait.mjs';
 import { CODEX_THREAD_RE } from './workSessionRuntime.mjs';
 import { brainFor } from './workBrain.mjs';
+import { refreshRestartBase } from './workAgentRecovery.mjs';
 import { begunTurnRefusal } from './workAgentTurnBegun.mjs';
 import { agentTurnSettlement } from './workAgentTurnOutcome.mjs';
 import { ensureArtifactDir, ensureFenceScratch } from './artifacts.mjs';
 import { agentBrowserHome } from './noWindowEnv.mjs';
+import { CLAUDE_SESSION_RE, RESUME_MARKERS } from './conversationIds.mjs';
+import { createDeliveryReporter } from './workDelivery.mjs';
+import { createLiveMessages } from './workLiveMessages.mjs';
 
 export function createAgentTurnExecution({
+  agentRepositories,
   makeBrief,
   baseRef,
   baseDir,
@@ -63,7 +69,9 @@ export function createAgentTurnExecution({
   postAgentActivity,
   postAgentParked,
   fetchAgentFiles,
+  makeLiveMessages = createLiveMessages,
 }) {
+  const reportDelivery = createDeliveryReporter();
   /** How long the final flush may hold the settle. Bounded because the settle
    *  is the turn's contract and the trace is a readout: a wedged uplink costs
    *  the tail of a trace, never the answer behind it. */
@@ -114,6 +122,11 @@ export function createAgentTurnExecution({
   /** `run` is the lane's record of this turn (`interrupted`, set by
    *  `interruptAgentTurns`); absent, nothing can interrupt it. */
   const runAgentTurnInPlace = async (job, { turnId, agentId, place, releaseSlot, postAgentTurn, measured, run = { interrupted: false } }) => {
+    let repositoryRun = null;
+    const setupController = new AbortController();
+    run.abortSetup = () => setupController.abort();
+    if (run.interrupted) setupController.abort();
+    try {
     // WORK THAT HAS BEGUN LIVES ON EXACTLY ONE BOX — read BEFORE anything is
     // cut, because `placeWtFor` would cut a rival branch of the same name. The
     // rule and its three-state branch measurement: workAgentTurnBegun.mjs.
@@ -124,7 +137,10 @@ export function createAgentTurnExecution({
         return;
       }
     }
-    const dir = placeWtFor(place);
+    if (!(await refreshRestartBase(job, repoRoot))) return;
+    repositoryRun = await agentRepositories?.prepare(job, place, { signal: setupController.signal });
+    measured.repositoryReceipts = repositoryRun?.receipts;
+    const dir = repositoryRun ?? placeWtFor(place);
     if (!dir) {
       // 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
@@ -294,10 +310,13 @@ export function createAgentTurnExecution({
       }
     }
     let seenThreadId = null;
+    const claudeMarker = rt === 'claude' ? sessionMetaPath(wt, RESUME_MARKERS.claude, agentId) : null;
+    let claudeResumeId = null;
+    try { const id = readFileSync(claudeMarker, 'utf8').trim(); if (CLAUDE_SESSION_RE.test(id)) claudeResumeId = id; } catch { /* unknown */ }
     const resume =
       rt === 'codex'
         ? Boolean(codexResumeId)
-        : rt === 'claude' && Boolean(ranMarker && existsSync(ranMarker));
+        : rt === 'claude' && (Boolean(claudeResumeId) || Boolean(ranMarker && existsSync(ranMarker)));
     /**
      * …AND THE HOME THAT THREAD IS FILED UNDER, KEPT PER AGENT (2026-09-29).
      *
@@ -454,7 +473,14 @@ export function createAgentTurnExecution({
     try {
       // A turn reads the base ref afresh. Changes the agent has made to its
       // own worktree cannot silently change the next turn's tools.
-      projectTools = prepareAgentTools(readBaseTools(repoRoot, baseRef()), rt, process.env, wt, { codexHome: codexAgentHome });
+      const sources = repositoryRun?.sources ?? [];
+      const source = sources.find((r) => r.wt === wt);
+      const snapshot = readBaseTools(source?.repoRoot ?? repoRoot, source?.baseRef ?? baseRef());
+      for (const other of sources.filter((r) => r !== source)) {
+        const base = readBaseTools(other.repoRoot, other.baseRef);
+        snapshot.instructions.push(...[...base.instructions, ...base.skillFiles].map((file) => ({ ...file, path: `repositories/${other.folder}/${file.path}` })));
+      }
+      projectTools = prepareAgentTools(snapshot, rt, process.env, wt, { codexHome: codexAgentHome, turnServers: repositoryRun?.tool ? { card_repositories: repositoryRun.tool.config } : {} });
       const mountsProjectMcp = TURN_PROFILES[posture]?.projectMcp === true && (rt === 'claude' || rt === 'codex');
       // A fenced posture on a runner that ignores its own file there (Codex's
       // `--ignore-user-config`) takes the servers as `fencedMount` instead.
@@ -475,6 +501,15 @@ export function createAgentTurnExecution({
         unmounted: [...projectTools.mcpUnmounted.map((u) => ({ ...u, source: 'project' })), ...(fencedMount ? fencedMount.unmounted : [])],
       });
       const agentTurnArgs = {
+        ...(rt === 'claude' ? { liveMessages: (run.live = makeLiveMessages({
+          scope: 'agent', turnId, cwd: wt, sessionMetaPath, interrupted: () => run.interrupted,
+          format: async (followup) => {
+            const attached = followup.attachments?.length ? await fetchAgentFiles(wt, followup.attachments.map((file) => ({ ...file, from: 'message' }))) : { message: [], card: [] };
+            return AGENT_HUMAN_KICKOFF({ agentName: job.agentName, message: followup.body + (followup.libraryPrompt ?? ''),
+              askedByName: followup.askedByName, task: job.task, cardThread: job.cardThread,
+              messageFiles: attached.message, cardFiles: files.card, position: job.position ?? 1, total: job.total ?? 1 });
+          },
+        })) } : {}),
         prompt:
           job.kind === 'task' && job.task
             ? AGENT_TASK_KICKOFF({
@@ -518,9 +553,10 @@ export function createAgentTurnExecution({
           // ARTIFACTS (0.94.0), while the server can show one — an agent's
           // land on its page, under the facts row.
           artifacts: getArtifactsAccepted(),
-        }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (projectTools.instructions ? `\n\n${projectTools.instructions}` : ''),
+        }) + (toolsNote ? `\n\n${toolsNote}` : '') + (artifactInstructions ? `\n\n${artifactInstructions}` : '') + `\n\n${INTERNAL_WAIT_CONTRACT}` + (projectTools.instructions ? `\n\n${projectTools.instructions}` : '') + (repositoryRun ? `\n\n${repositoryRun.note}\nRepository command argv: ${JSON.stringify([repositoryRun.tool?.config.command, ...(repositoryRun.tool?.config.args.slice(0, -1) ?? []), "__repository", "<name>"])}` : ''),
         agentTools: projectTools,
-        ...((projectTools.codexHome || fencedMount) ? { mcpEnv: { ...(projectTools.codexHome ? { CODEX_HOME: projectTools.codexHome } : {}), ...(fencedMount?.env ?? {}) } } : {}),
+        writableDirs: repositoryRun?.writableDirs,
+        ...((projectTools.codexHome || fencedMount || repositoryRun?.tool) ? { mcpEnv: { ...(projectTools.codexHome ? { CODEX_HOME: projectTools.codexHome } : {}), ...(fencedMount?.env ?? {}), ...(repositoryRun?.tool?.env ?? {}) } } : {}),
         // NOBODY IS AT THIS SCREEN (2026-09-29): no display, BROWSER=none, and
         // a browser profile of the agent's own, kept beside its Codex home —
         // so a Chrome it starts to look at its page never reaches the
@@ -542,7 +578,11 @@ export function createAgentTurnExecution({
         cwd: wt,
         runtime: rt,
         resume,
-        resumeThreadId: codexResumeId || undefined,
+        resumeThreadId: codexResumeId || claudeResumeId || undefined,
+        onInit: (init) => {
+          if (claudeMarker && CLAUDE_SESSION_RE.test(init.sessionId ?? ''))
+            try { writeFileSync(claudeMarker, init.sessionId); } catch { /* best effort */ }
+        },
         onThreadId: (id) => {
           seenThreadId = String(id ?? '').trim() || seenThreadId;
         },
@@ -558,7 +598,7 @@ export function createAgentTurnExecution({
         // board past ~90 seconds.
         onActivity: (a) => {
           brief?.append(a?.kind ?? 'activity', a?.full ?? a?.label);
-          const line = a?.label;
+          let line = a?.label;
           if (!line) return;
           // THE TRACE TAKES EVERY LINE; the pulse takes one every two
           // seconds. Two channels, one stream, and the drop-sampler stays a
@@ -573,7 +613,12 @@ export function createAgentTurnExecution({
           // daemon carried for all of them. The PULSE below is deliberately
           // still `line`: it is one overwritten line on a board, and a
           // paragraph there would be a paragraph nobody can read.
-          if (!doubledKinds || !doubledKinds.has(a.kind)) trace.prose(a.kind, a.full ?? line);
+          if (!doubledKinds || !doubledKinds.has(a.kind)) {
+            const full = a.full ?? line;
+            const readable = trace.prose(a.kind, full);
+            if (readable === null) return;
+            if (readable !== full) line = envScrub(readable).replace(/\s+/g, ' ').trim().slice(0, 160);
+          }
           const now = Date.now();
           if (now - (lastAgentBeat.get(agentId) ?? 0) < 2_000) return;
           lastAgentBeat.set(agentId, now);
@@ -612,10 +657,12 @@ export function createAgentTurnExecution({
         // (runTurn.mjs, `initHarvestFor`). An agent-only box learns from the
         // startup probe and its Terminal tabs.
         onSpawn: (ch) => {
+          if (rt !== 'claude') reportDelivery('agent', job, 'taken');
           brief?.running(true);
           ch.once('close', () => { if (child === ch) brief?.running(false); });
           child = ch;
           spawnedChildren.add(ch);
+          measured.ranCli = true;
           // The AGENT it serves — what the machine snapshot charges this
           // child's memory to.
           workChildren.set(ch, agentId);
@@ -664,12 +711,30 @@ export function createAgentTurnExecution({
           void postAgentActivity(agentId, 'resuming after an internal wait');
         } }
       );
+      out = await finishRepositoryDelivery({
+        job, run: repositoryRun, out, answer: () => lastAnswer,
+        resume: async (prompt) => {
+          lastAnswer = null;
+          const counted = usage;
+          return runCli({
+            ...agentTurnArgs, prompt, liveContinuation: true,
+            onUsage: (next) => agentTurnArgs.onUsage(Object.fromEntries(
+              ['input', 'output', 'cacheCreate', 'cacheRead'].map((k) =>
+                [k, (counted?.[k] ?? 0) + (next?.[k] ?? 0)])
+            )),
+            writableDirs: repositoryRun.sourcesNow().filter((r) => r.wt !== wt).map((r) => r.wt),
+            resume: true,
+            resumeThreadId: seenThreadId ?? agentTurnArgs.resumeThreadId,
+          });
+        },
+      });
     } finally {
       await brief?.stop();
       // What the CLI counted, for the lane's catch if anything below throws.
       measured.usage = usage;
       measured.model = model;
       projectTools?.cleanup();
+
       /**
        * THE TAIL, BEFORE THE SETTLE — so the last thing the agent did is on
        * the record by the time the board is told the turn is over.
@@ -721,7 +786,7 @@ export function createAgentTurnExecution({
     }
 
 
-    const commits = commitsBetween(wt, before);
+    const commits = repositoryRun ? [...new Set(repositoryRun.receipts().map((r) => r.sha))].slice(0, 50) : commitsBetween(wt, before);
     /**
      * A PERSON INTERRUPTED IT (Interrupt now). Whatever the CLI printed was
      * cut off, so there is no outcome to read: the turn reports `interrupted`
@@ -771,12 +836,14 @@ export function createAgentTurnExecution({
       // reported as `nothing` — it did not deliver and it did not ask.
       await postAgentParked(limit, rt);
     }
+    if (job.kind === 'merge_resolve' && repositoryRun) body.mergeResolved = allResolutionsCommitted(repositoryRun.sourcesNow());
     const reply = await postAgentTurn(body);
     // The queue just emptied. Run the project's own check and the AI
     // pre-review HERE, in the worktree we are already standing in and still
     // hold the lock on — see `runReviewEntry`. Only after the settle that may
     // say delivered: the three `nothing` settles never opened it.
     if (final && reply?.review === true) await runReviewEntry(agentId, wt, job.agentName);
+    } finally { await repositoryRun?.tool?.close(); }
   };
 
   return { runAgentTurnInPlace, commitsBetween };

package/bin/lib/workAgentTurnOutcome.mjs

@@ -26,6 +26,7 @@ import { parseTurnResult } from './agentPlan.mjs';
 import { changedArtifacts, scanArtifacts } from './artifacts.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { usableImageArtifact } from './imageArtifact.mjs';
+import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 
 export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage, model = null, commits, artifactsBefore, branch, wt }) {
   const res = (lastAnswer && parseTurnResult(lastAnswer)) || parseTurnResult(out);
@@ -39,7 +40,9 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
    * makes the match mean what it says: the CLI failed and this is the
    * sentence it failed with.
    */
-  const limit = res ? null : limitLine(out);
+  // An unreadable protocol object is not a native CLI diagnostic either.
+  const readableOut = res ? '' : withoutTurnDeclaration(out);
+  const limit = res ? null : limitLine(readableOut);
   /** What the caller posts, and whether it is the one settle that may say
    *  delivered (the only one whose reply can open the review-entry beat).
    *  Every one carries the model the CLI said it ran on, when it said
@@ -60,13 +63,16 @@ export function agentTurnSettlement({ turnId, job, kind, out, lastAnswer, usage,
   }
 
   if (!res) {
+    const raw = lastAnswer || out;
+    const readable = lastAnswer ? withoutTurnDeclaration(raw) : readableOut;
     return report({
       turnId,
       outcome: 'nothing',
       // The CLI's own words when it produced any. A turn that explained why
       // it stopped is far more use than "the agent stopped".
-      answer: out.trim()
-        ? envScrub(out).slice(-1500)
+      answer: raw.trim()
+        ? readable.trim() ? envScrub(readable).slice(-1500)
+          : 'The turn returned an unreadable outcome declaration. This work has not been delivered.'
         : 'the turn produced no output on the machine — its CLI may be signed out',
       ...(commits.length ? { commits } : {}),
       ...(usage ? { usage } : {}),

package/bin/lib/workAgentTurns.mjs

@@ -26,9 +26,11 @@ import { createAgentTurnReports } from './workAgentTurnReports.mjs';
 import { createAgentTurnExecution } from './workAgentTurnExecution.mjs';
 import { failedTurnSettlement } from './workAgentTurnOutcome.mjs';
 import { killGroup } from './processGroup.mjs';
+import { createDeliveryReporter } from './workDelivery.mjs';
 import { createAgentBriefRunner } from './workAgentBriefRunner.mjs';
 
 export function createWorkAgentTurns({
+  agentRepositories,
   REJECT_RETRY_MS,
   baseRef,
   inPlace,
@@ -44,6 +46,7 @@ export function createWorkAgentTurns({
   artifacts,
   runReviewEntry,
   publishAgentBranch,
+  stopAgentPublishing = () => {},
   admit,
   workChildren,
   agentPublished,
@@ -52,6 +55,7 @@ export function createWorkAgentTurns({
   fetchAgentFiles,
   makeBrief = createAgentBriefRunner({ admit, workChildren }),
 }) {
+  const reportDelivery = createDeliveryReporter();
   const {
     postAgentTurn,
     postAgentTrace,
@@ -68,11 +72,9 @@ export function createWorkAgentTurns({
   // A TIME. The server types the next prompt when this one lands; this side
   // does the work and reports what happened.
   //
-  // NO MCP ON THIS TURN AT ALL. Everything the agent needs to say fits in its
-  // final JSON object, and everything it needs to PROVE is measured from git
-  // here afterwards — an agent naming its own commit shas would be a receipt
-  // pointing at whatever it liked. That is also what keeps this feature from
-  // adding a token kind to a scope map that has silently shipped empty twice.
+  // Outcomes stay in the final JSON; commits are measured from git. The
+  // local card-repository tool is a turn-scoped capability, never a machine
+  // credential handed to the CLI.
   //
   // UNLEASED, unlike a plan or a kill. The server hands out at most one turn
   // per agent per poll and its settle is conditional on the row still being
@@ -110,6 +112,7 @@ export function createWorkAgentTurns({
   const stoppedFor = new Map(); // agentId -> when
 
   const { runAgentTurnInPlace, commitsBetween } = createAgentTurnExecution({
+    agentRepositories,
     makeBrief,
     baseRef,
     baseDir,
@@ -184,7 +187,8 @@ export function createWorkAgentTurns({
     let settled = false;
     const settleOnce = (body) => {
       settled = true;
-      return postAgentTurn(body);
+      const liveMessages = agentRuns.get(turnId)?.live?.receipts();
+      return postAgentTurn({ ...body, ...(liveMessages?.ids.length ? { liveMessages } : {}) });
     };
 
     // A WRITER on the agent's own place — see the lane header. Only `a-<id>`
@@ -192,14 +196,15 @@ export function createWorkAgentTurns({
     // be a tab's directory, where a turn is a reader by the product's own law.
     const run = agentRuns.get(turnId) ?? { place, interrupted: false };
     await inPlace(place, place.startsWith('a-'), async () => {
+      run.waitingReason = null;
       try {
         await runAgentTurnInPlace(job, { turnId, agentId, place, releaseSlot, postAgentTurn: settleOnce, measured, run });
         if (run.interrupted && measured.ranCli) stoppedFor.set(agentId, Date.now());
       } catch (error) {
         if (settled) return;
-        const commits = measured.wt ? commitsBetween(measured.wt, measured.before) : [];
+        const commits = measured.repositoryReceipts ? [...new Set(measured.repositoryReceipts().map((r) => r.sha))].slice(0, 50) : measured.wt ? commitsBetween(measured.wt, measured.before) : [];
         if (run.interrupted) {
-          await postAgentTurn({ turnId, outcome: 'nothing', interrupted: true, ran: true, commits, ...(measured.usage ? { usage: measured.usage } : {}) });
+          await postAgentTurn({ turnId, outcome: 'nothing', interrupted: true, ran: measured.ranCli === true, commits, ...(measured.usage ? { usage: measured.usage } : {}) });
           return;
         }
         await postAgentTurn(
@@ -214,6 +219,9 @@ export function createWorkAgentTurns({
           })
         );
       }
+    }, () => {
+      run.waitingReason = 'waiting for this turn to finish';
+      reportDelivery('agent', job, 'queued', run.waitingReason);
     });
     /**
      * …AND THEN PUBLISH, IF THE PROJECT PUBLISHES.
@@ -266,7 +274,12 @@ export function createWorkAgentTurns({
     let saidPressure = false;
     for (const job of list.slice(0, 4)) {
       const id = String(job?.id || '');
-      if (!id || agentTurns.has(id)) continue;
+      if (!id) continue;
+      if (agentTurns.has(id)) {
+        const reason = agentRuns.get(id)?.waitingReason;
+        if (reason) reportDelivery('agent', job, 'queued', reason);
+        continue;
+      }
       const held = agentReported.get(id);
       if (reportsOnly && !held) continue;
       // A body the server REFUSED waits out its backoff — still held, so the
@@ -321,8 +334,15 @@ export function createWorkAgentTurns({
        * would all be admitted against the same stale count. The reserved slot
        * is what the next iteration sees. See admission.mjs.
        */
+      const missing = agentRepositories?.missing(job);
+      if (missing) {
+        if (!saidPressure) { saidPressure = true; note(missing); }
+        void postAgentActivity(String(job.agentId), missing);
+        continue; // no CLI, no failed settle; login and the next poll remeasure
+      }
       const hold = admit('churn');
       if (hold) {
+        reportDelivery('agent', job, 'queued', hold.reason);
         if (!saidPressure) {
           saidPressure = true;
           note(`${c.cyan('agent')} ${c.dim(`— holding off: ${hold.reason}`)}`);
@@ -367,6 +387,9 @@ export function createWorkAgentTurns({
    * a wedged uplink must not hold the stand-down open.
    */
   const settleAgentTurns = async (sentence) => {
+    // Stand-down precedes flushing held replies; a late accepted reply must
+    // never push this displaced machine's work after the holder has moved.
+    stopAgentPublishing();
     const answer = String(sentence ?? '').slice(0, 1000);
     const posts = [];
     for (const turnId of agentTurns) {
@@ -393,6 +416,7 @@ export function createWorkAgentTurns({
       if (run) {
         if (!run.interrupted) note(`${c.cyan('agent')} ${c.dim('— interrupting the running turn')}`);
         run.interrupted = true;
+        run.abortSetup?.();
         const child = agentChildren.get(run.place);
         if (child) killGroup(child);
         continue;

package/bin/lib/workDelivery.mjs

@@ -0,0 +1,21 @@
+/** A measured wait belongs to its message. Reports decorate the queue and
+ * never gate a turn; retries come with the next measurement/poll. */
+import { DAEMON_INSTANCE, FLEET_URL } from './config.mjs';
+import { fleetRequest } from './fleetPost.mjs';
+import { fleetEndpoint } from './fleetWire.mjs';
+
+export function createDeliveryReporter(request = fleetRequest, now = Date.now) {
+  const said = new Map();
+  return (scope, job, state, reason) => {
+    const key = `${scope}:${job.id}`;
+    const value = `${state}:${reason ?? ''}`;
+    const prior = said.get(key);
+    if (prior?.value === value && now() - prior.at < 10_000) return;
+    said.set(key, { value, at: now() });
+    // Bound a day-long daemon's decoration cache.
+    if (said.size > 500) said.delete(said.keys().next().value);
+    void request(fleetEndpoint('turn-delivery', FLEET_URL), { timeoutMs: 10_000,
+      body: { scope, turnId: job.id, instance: DAEMON_INSTANCE, ...(Number.isInteger(job.attempt) ? { attempt: job.attempt } : {}), state, ...(reason ? { reason } : {}) },
+    }).then(result => { if (!result.ok && said.get(key)?.value === value) said.delete(key); }).catch(() => { said.delete(key); });
+  };
+}

package/bin/lib/workDiffs.mjs

@@ -1,5 +1,6 @@
 /** Commit diff requests and their bounded reports. */
 import { FLEET_URL, FLEET_TOKEN, USER_AGENT } from './config.mjs';
+import { listStoredProjects } from './credentials.mjs';
 import { git, GIT_WIDE_BUFFER, OBJECT_ID_RE } from './git.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { scrub, scrubCut } from './uplinkScrub.mjs';
@@ -21,7 +22,9 @@ function gitBig(args, cwd) {
   }
 }
 
-export function createWorkDiffs({ repoRoot }) {
+export function createWorkDiffs({ repoRoot, repositories }) {
+  // The picker may have changed the active token since config was imported.
+  const roots = repositories ?? listStoredProjects().find((entry) => entry.fleetToken === FLEET_TOKEN)?.repositories ?? {};
   const DIFF_DONE_URL = fleetEndpoint('diff-done', FLEET_URL);
 
   /**
@@ -82,24 +85,28 @@ export function createWorkDiffs({ repoRoot }) {
       // In-flight guard, not a cache: the server stops offering a sha the
       // moment it settles, so this only stops the SAME poll's job being
       // started twice while its `git show` is still running.
-      if (servedDiffs.has(sha)) continue;
-      servedDiffs.add(sha);
+      const jobKey = `${job.repo ?? ''}:${sha}`;
+      if (servedDiffs.has(jobKey)) continue;
+      servedDiffs.add(jobKey);
+      const cwd = job.repo ? roots[job.repositoryName] : repoRoot;
+      const report = (body) => postDiff({ ...body, ...(job.repo ? { repo: job.repo } : {}) });
       void (async () => {
         try {
+          if (!cwd) { await report({ sha, error: 'This repository has no checkout on this machine. Run flowviant login in that checkout.' }); return; }
           let commit = '';
           try {
-            commit = gitBig(['rev-parse', '--verify', '--quiet', `${sha}^{commit}`], repoRoot);
+            commit = gitBig(['rev-parse', '--verify', '--quiet', `${sha}^{commit}`], cwd);
           } catch (e) {
             // Exit 1 is `--verify --quiet`'s "not a commit here" (absent,
             // ambiguous, or another object type); anything else is git's own
             // failure, relayed in its words as before.
             if (e?.status !== 1) {
-              await postDiff({ sha, error: scrubCut(e?.message || e, 500) });
+              await report({ sha, error: scrubCut(e?.message || e, 500) });
               return;
             }
           }
           if (!/^[0-9a-f]{40,64}$/.test(commit)) {
-            await postDiff({ sha, error: 'no such commit on this machine' });
+            await report({ sha, error: 'no such commit on this machine' });
             return;
           }
           let patch = '';
@@ -109,13 +116,13 @@ export function createWorkDiffs({ repoRoot }) {
             // date already reached the card on the worktree sweep, and
             // repeating them inside the patch would put a second copy above
             // every hunk.
-            patch = scrub(gitBig(['show', '--patch', '--format=', commit], repoRoot));
+            patch = scrub(gitBig(['show', '--patch', '--format=', commit], cwd));
           } catch (e) {
-            await postDiff({ sha, error: scrubCut(e?.message || e, 500) });
+            await report({ sha, error: scrubCut(e?.message || e, 500) });
             return;
           }
           try {
-            const raw = gitBig(['show', '--numstat', '--format=', commit], repoRoot);
+            const raw = gitBig(['show', '--numstat', '--format=', commit], cwd);
             for (const line of raw.split('\n')) {
               if (!line.trim()) continue;
               const [a, d, ...rest] = line.split('\t');
@@ -133,7 +140,7 @@ export function createWorkDiffs({ repoRoot }) {
             /* a header without counts still beats no diff */
           }
           const truncated = Buffer.byteLength(patch, 'utf8') > MAX_PATCH_BYTES;
-          await postDiff({
+          await report({
             sha,
             // Cut on a LINE boundary: half a hunk header renders as garbage,
             // and the viewer says the patch was truncated either way.
@@ -144,7 +151,7 @@ export function createWorkDiffs({ repoRoot }) {
             truncated,
           });
         } finally {
-          servedDiffs.delete(sha);
+          servedDiffs.delete(jobKey);
         }
       })();
     }