flowviant 0.117.0 → 0.124.1

package/bin/lib/workAgentTurns.mjs

@@ -25,8 +25,12 @@ import { c, note } from './ui.mjs';
 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,
@@ -42,13 +46,16 @@ export function createWorkAgentTurns({
   artifacts,
   runReviewEntry,
   publishAgentBranch,
+  stopAgentPublishing = () => {},
   admit,
   workChildren,
   agentPublished,
   agentRemoteAt,
   /** The turn's files, fetched into its worktree (workAttachments.mjs, 0.112.0). */
   fetchAgentFiles,
+  makeBrief = createAgentBriefRunner({ admit, workChildren }),
 }) {
+  const reportDelivery = createDeliveryReporter();
   const {
     postAgentTurn,
     postAgentTrace,
@@ -65,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
@@ -91,8 +96,24 @@ export function createWorkAgentTurns({
    * directory names, and those are places.
    */
   const agentChildren = new Map(); // placeId -> child process
+  /**
+   * INTERRUPT NOW (2026-10-13) — each turn this lane has taken: its place and
+   * whether a person asked to stop it. A stop kills the CLI's PROCESS GROUP
+   * (it is spawned detached, so the commands it started go with it); a turn
+   * asked to stop before it spawned never spawns.
+   */
+  const agentRuns = new Map(); // turnId -> { place, interrupted }
+  /** Turns answered `ran: false` here, so a roster read made before that
+   *  settle landed is not answered again at once. */
+  const notRunningSaid = new Map(); // turnId -> when
+  /** Agents whose run this lane just stopped: the next turn is the one sent to
+   *  interrupt it, and is told so even when the roster that handed it over was
+   *  read before the stop's settle landed. Taken once, for a little while. */
+  const stoppedFor = new Map(); // agentId -> when
 
   const { runAgentTurnInPlace, commitsBetween } = createAgentTurnExecution({
+    agentRepositories,
+    makeBrief,
     baseRef,
     baseDir,
     repoRoot,
@@ -166,18 +187,26 @@ 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>`
     // places: those are agents' by construction, and anything else here would
     // 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 });
+        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: measured.ranCli === true, commits, ...(measured.usage ? { usage: measured.usage } : {}) });
+          return;
+        }
         await postAgentTurn(
           failedTurnSettlement({
             turnId,
@@ -190,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.
@@ -235,15 +267,21 @@ export function createWorkAgentTurns({
     }
   };
 
-  const processAgentTurnJobs = (jobs) => {
+  const processAgentTurnJobs = (jobs, { reportsOnly = false } = {}) => {
     const list = Array.isArray(jobs) ? jobs : [];
     pruneHeldReports(list);
     /** One deferral line per tick, however many turns were offered. */
     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
       // CLI is never re-run in the meantime.
       if (held && (agentRejectedUntil.get(id) ?? 0) > Date.now()) continue;
@@ -296,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}`)}`);
@@ -306,11 +351,16 @@ export function createWorkAgentTurns({
       }
       const releaseSlot = admit.reserve();
       agentTurns.add(id);
-      void runAgentTurn(job, releaseSlot).finally(() => {
+      agentRuns.set(id, { place: String(job.placeId), interrupted: false });
+      const stopped = stoppedFor.get(String(job.agentId));
+      stoppedFor.delete(String(job.agentId));
+      const run = stopped != null && Date.now() - stopped < 120_000 ? { ...job, interrupted: true } : job;
+      void runAgentTurn(run, releaseSlot).finally(() => {
         // Belt for every path that never reached a spawn — the release is
         // idempotent, so the normal case releases twice.
         releaseSlot();
         agentTurns.delete(id);
+        agentRuns.delete(id);
       });
     }
   };
@@ -337,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) {
@@ -347,5 +400,32 @@ export function createWorkAgentTurns({
     await Promise.allSettled(posts);
   };
 
-  return { processAgentTurnJobs, settleAgentTurns, agentTurns, agentChildren, agentReported };
+  /**
+   * THE AGENT RUNS A PERSON ASKED TO STOP (`roster.interruptAgentTurns`, read
+   * before the jobs). One this lane is running is stopped — the CLI's group
+   * killed — and reports `interrupted` once its CLI is gone. One that finished
+   * here keeps its own settle. One this lane is not running is answered `ran:
+   * false`, and the server puts it back in the queue untouched.
+   */
+  const interruptAgentTurns = (ids) => {
+    const at = Date.now();
+    for (const [id, when] of notRunningSaid) if (at - when > 30_000) notRunningSaid.delete(id);
+    for (const id of Array.isArray(ids) ? ids : []) {
+      if (typeof id !== 'string' || !id) continue;
+      const run = agentRuns.get(id);
+      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;
+      }
+      if (agentReported.has(id) || notRunningSaid.has(id)) continue;
+      notRunningSaid.set(id, at);
+      void postAgentTurn({ turnId: id, outcome: 'nothing', interrupted: true, ran: false }).catch(() => {});
+    }
+  };
+
+  return { processAgentTurnJobs, interruptAgentTurns, settleAgentTurns, agentTurns, agentChildren, agentReported };
 }

package/bin/lib/workArtifactReconcile.mjs

@@ -0,0 +1,79 @@
+/**
+ * AN IDLE AGENT'S DELIVERY, RECONCILED WITHOUT A TURN (2026-10-11).
+ *
+ * A local discard reached the server only when a turn settled, so an agent
+ * waiting in Review kept every stored file a daemon had not relayed removing:
+ * the marketing imagery card showed nine images while its worktree held the
+ * two the person kept, and nothing would change until somebody sent another
+ * message. So each agent worktree this machine holds is measured against its
+ * stored inventory once per process, under the place's writer lock and never
+ * beside a turn — the reporter's own evidence rule (artifactIteration.mjs)
+ * decides what is a discard. Only agents: a tab's next turn is the natural
+ * moment to reconcile a conversation, and a delivery in Review has none.
+ *
+ * A failure is said in the log and tried again on a later beat, a bounded
+ * number of times; the stored files stay listed, which is the truth.
+ */
+import { existsSync } from 'node:fs';
+
+/** Attempts per agent per process, and the wait between two of them. */
+const MAX_TRIES = 4;
+const RETRY_MS = 60_000;
+
+export function createWorkArtifactReconcile({
+  artifacts,
+  placeLocks,
+  inPlace,
+  placeDir,
+  beforeArtifacts,
+  getArtifactsAccepted,
+  log = () => {},
+  now = Date.now,
+}) {
+  const done = new Set(); // agent places reconciled by this process
+  const tries = new Map(); // agent place -> { n, at }
+  let sweeping = null;
+
+  const reconcileOne = async (place) => {
+    const wt = placeDir(place);
+    if (!wt || !existsSync(wt)) return;
+    const agentId = place.slice(2);
+    try {
+      await inPlace(place, true, () => artifacts.reconcile({ placeDir: wt, before: beforeArtifacts(wt), agentId }));
+      done.add(place);
+      tries.delete(place);
+    } catch (error) {
+      const n = (tries.get(place)?.n ?? 0) + 1;
+      tries.set(place, { n, at: now() });
+      log(`agent ${agentId}: artifact cleanup incomplete — ${error?.message ?? error}` +
+        (n >= MAX_TRIES ? ' (not retried again until the daemon restarts)' : ''));
+    }
+  };
+
+  /** The roster's live places; agent ones are `a-<agentId>`. Never awaited by the poll. */
+  const reconcileIdleArtifacts = (activeIds) => {
+    if (!Array.isArray(activeIds) || !getArtifactsAccepted()) return null;
+    if (sweeping) return sweeping;
+    const live = new Set(activeIds);
+    for (const id of done) if (!live.has(id)) done.delete(id);
+    for (const id of tries.keys()) if (!live.has(id)) tries.delete(id);
+    const due = activeIds.filter((place) => {
+      if (typeof place !== 'string' || !place.startsWith('a-') || place.length <= 2) return false;
+      if (done.has(place) || placeLocks.has(place)) return false; // a turn or a merge is there
+      const t = tries.get(place);
+      return !t || (t.n < MAX_TRIES && now() - t.at >= RETRY_MS);
+    });
+    if (due.length === 0) return null;
+    // One place at a time: each is an inventory read and its removals.
+    sweeping = (async () => {
+      try {
+        for (const place of due) await reconcileOne(place);
+      } finally {
+        sweeping = null;
+      }
+    })();
+    return sweeping;
+  };
+
+  return { reconcileIdleArtifacts };
+}

package/bin/lib/workCappedTurn.mjs

@@ -60,6 +60,7 @@ export async function runCappedTurn({
   onSpawn = () => {},
   onInit = () => {},
   removeTranscript = removeTranscriptSoon,
+  signal,
 }) {
   // Wiring mistakes, refused before anything spawns: a hook inside turnArgs
   // would be silently replaced below, and a missing cap would fire at once.
@@ -74,7 +75,14 @@ export async function runCappedTurn({
   const capped = new Promise((resolve) => {
     stopWaiting = resolve;
   });
+  const cancel = () => {
+    wedged = true;
+    try { child?.kill('SIGKILL'); } catch { /* already gone */ }
+    stopWaiting('');
+  };
+  signal?.addEventListener('abort', cancel, { once: true });
   try {
+    if (signal?.aborted) { cancel(); return { out: '', wedged, spawned: false, sessionId }; }
     const turn = runTurn({
       ...turnArgs,
       onInit: (i) => {
@@ -96,11 +104,13 @@ export async function runCappedTurn({
         }, capMs);
         timer.unref?.();
         onSpawn(ch);
+        if (signal?.aborted) cancel();
       },
     });
     const out = await Promise.race([turn, capped]);
     return { out, wedged, spawned: child !== null, sessionId };
   } finally {
+    signal?.removeEventListener('abort', cancel);
     if (timer) clearTimeout(timer);
     if (child) workChildren.delete(child);
     releaseSlot();

package/bin/lib/workCommandAudit.mjs

@@ -64,7 +64,14 @@ export function createCommandAudit({ sessionId, turnId, runtime, cwd }) {
     // used to cut the command at 2000 before it reached this scrub, so a
     // secret straddling that character kept its prefix. They now hand a
     // bounded window, and the server's cap is applied here, last.
-    auditBatch.push({ command: scrubCut(a.command, MAX_COMMAND_CHARS), at: new Date().toISOString() });
+    auditBatch.push({ command: scrubCut(a.command, MAX_COMMAND_CHARS), at: new Date().toISOString(),
+      ...(a.observation ? { observation: {
+        ...(a.observation.id ? { id: scrubCut(a.observation.id, 160) } : {}),
+        outcome: a.observation.outcome ?? 'unknown',
+        ...(Number.isSafeInteger(a.observation.exitCode) ? { exitCode: a.observation.exitCode } : {}),
+        ...(a.observation.errorCategory ? { errorCategory: a.observation.errorCategory } : {}),
+      } } : {}),
+    });
     if (auditBatch.length >= 25) flushAudit();
   };
   return { flushAudit, auditCommand };

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);
         }
       })();
     }

package/bin/lib/workLiveMessages.mjs

@@ -0,0 +1,129 @@
+/** One live conversation's input relay, shared by tabs, capture chats and
+ * card agents. The server owns queue/holder checks; the CLI echo owns receipt.
+ * Durable receipts plus native transcript UUIDs cover a restart before POST.
+ * No model call, new process, or re-send of an unacknowledged write here. */
+import { readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { fleetRequest } from './fleetPost.mjs';
+import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
+import { DAEMON_INSTANCE, FLEET_URL } from './config.mjs';
+import { messageIdsForSession } from './claudeSessions.mjs';
+
+export function createLiveMessages({ scope, turnId, attempt, cwd, sessionMetaPath, format, interrupted = () => false,
+  request = fleetRequest, nativeIds = messageIdsForSession, setTimer = setInterval, clearTimer = clearInterval, finalFlushMs = 1_000 }) {
+  const identity = { scope, turnId, instance: DAEMON_INSTANCE, ...(attempt !== undefined ? { attempt } : {}) };
+  const file = sessionMetaPath(cwd, 'flowviant-live-messages', turnId);
+  let sessionId = null;
+  let timer = null;
+  let stopped = false;
+  let send = null;
+  let flight = null;
+  let posting = null;
+  const sent = new Set();
+  const initialIds = new Set();
+  let initialId = turnId;
+  const taken = new Set();
+  const confirmed = new Set();
+  const outstanding = () => [...taken].filter((id) => !confirmed.has(id));
+  try {
+    const saved = JSON.parse(readFileSync(file, 'utf8'));
+    sessionId = saved.sessionId;
+    for (const id of saved.ids ?? []) if (typeof id === 'string') taken.add(id);
+  } catch { /* no measured receipts yet */ }
+  const save = () => {
+    if (!file) return;
+    // Keep only ids and the CLI's conversation id, never the person's words.
+    const temporary = `${file}.tmp-${process.pid}`;
+    try {
+      writeFileSync(temporary, JSON.stringify({ sessionId, ids: outstanding() }), { mode: 0o600, flag: 'wx' });
+      renameSync(temporary, file); // a crash leaves the previous complete receipt
+    } catch { /* the native transcript remains the recovery evidence */ }
+    finally { try { rmSync(temporary, { force: true }); } catch { /* best effort */ } }
+  };
+  const flush = () => {
+    if (posting) return posting;
+    if (!outstanding().length) return Promise.resolve(true);
+    posting = (async () => {
+      for (const id of outstanding()) {
+        const result = await request(fleetEndpoint('live-turn-messages-taken', FLEET_URL), { body: { ...identity, ids: [id] }, timeoutMs: 15_000 });
+        if (!result.ok || result.json?.data?.taken !== true) return false;
+        confirmed.add(id);
+        save();
+      }
+      return true;
+    })().catch(() => false).finally(() => { posting = null; });
+    return posting;
+  };
+  const onTaken = (id) => {
+    if (initialIds.has(id) || taken.has(id)) return;
+    taken.add(id);
+    save(); // synchronous before the report or final settlement
+    void flush();
+  };
+  const tick = () => {
+    if (flight || stopped || interrupted() || !send) return flight ?? Promise.resolve();
+    flight = (async () => {
+      await flush();
+      if (stopped || interrupted()) return;
+      const result = await request(fleetEndpoint('live-turn-messages', FLEET_URL), { body: identity, timeoutMs: 15_000 });
+      if (!result.ok) {
+        if (isConsideredRefusal(result.status)) { if (timer) clearTimer(timer); timer = null; }
+        return;
+      }
+      if (!result.json?.data?.active) return;
+      const seen = sessionId ? nativeIds(cwd, sessionId) : null;
+      for (const message of result.json.data.messages ?? []) {
+        if (stopped || interrupted()) break;
+        if (taken.has(message.id) || seen?.has(message.id)) { onTaken(message.id); continue; }
+        if (sent.has(message.id)) continue;
+        const prompt = await format(message);
+        if (!stopped && !interrupted() && send(message.id, prompt)) sent.add(message.id);
+      }
+    })().catch(() => {}).finally(() => { flight = null; });
+    return flight;
+  };
+  return {
+    turnId, onTaken, tick,
+    connected: () => Boolean(send) && !stopped,
+    get initialId() { return initialId; },
+    initialPrompt(prompt, resumeId, resume = Boolean(resumeId), continuation = false) {
+      initialId = turnId;
+      sessionId = resume || resumeId ? resumeId || sessionId : null;
+      // A daemon-authored correction continues the same conversation with
+      // new instructions. Restart recovery alone replaces the old prompt.
+      if (continuation) {
+        initialId = randomUUID();
+        initialIds.add(initialId);
+        return prompt;
+      }
+      if ((resume || resumeId) && sessionId && nativeIds(cwd, sessionId)?.has(turnId)) {
+        onTaken(turnId); // the native transcript proves the original prompt was read
+        initialId = randomUUID(); // continuation, never a second copy of the user's UUID
+        initialIds.add(initialId);
+        return 'Continue the request already in this conversation after the process stopped. Inspect the work in flight before repeating a command, and finish under the same operating contract.';
+      }
+      return prompt;
+    },
+    onInit(id) { sessionId = id; save(); },
+    connect(writer) {
+      sent.clear(); // a new child can retry writes the previous child never echoed
+      stopped = false;
+      send = writer;
+      timer = setTimer(() => void tick(), 1_000);
+      timer?.unref?.();
+      void tick();
+    },
+    receipts: () => ({ ...identity, ids: outstanding() }),
+    async stop() {
+      stopped = true;
+      if (timer) clearTimer(timer);
+      timer = null;
+      // A completed CLI never waits on a queue read or attachment download.
+      // Give receipts one bounded chance; the final report carries the rest.
+      let cap;
+      try { await Promise.race([flush(), new Promise(resolve => { cap = setTimeout(resolve, finalFlushMs); })]); }
+      finally { clearTimeout(cap); }
+      if (!outstanding().length && file) try { rmSync(file, { force: true }); } catch { /* best effort */ }
+    },
+  };
+}

package/bin/lib/workPlaceReports.mjs

@@ -23,6 +23,7 @@ import { fleetEndpoint } from './fleetWire.mjs';
 import { isValidPlace } from './workPlaces.mjs';
 
 export function createWorkPlaceReports({
+  repositoryPlaces,
   repoRoot,
   baseRef,
   placeOf,
@@ -101,6 +102,10 @@ export function createWorkPlaceReports({
     const wt = placeDir(sessionId);
     const d = worktreeDiff(wt, baseRef());
     if (!d) return null;
+    const siblings = repositoryPlaces?.entries(place).filter((r) => r.writable) ?? [];
+    if (siblings.length) {
+      d.commits = siblings.flatMap((r) => (worktreeDiff(r.wt, r.baseRef)?.commits ?? []).map((commit) => ({ ...commit, repo: r.id }))).slice(0, 50);
+    }
     // WHAT IS LISTENING in this worktree, attributed by the CWD of the process
     // holding the socket. It rides the sweep the daemon already makes rather
     // than taking a beat of its own, exactly as the commit trailers do — and

package/bin/lib/workPlaces.mjs

@@ -12,7 +12,8 @@
  * the session lane's turn intake both go through it (audit 2026-10-10, F141),
  * so a lane that learns a place cannot store one unvalidated.
  */
-import { existsSync } from 'node:fs';
+import { readRepositoryPlace } from './repositoryPlaces.mjs';
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { git, isSafePathSegment, hasCommits, gitFailure, sessionBranch } from './git.mjs';
 
@@ -51,7 +52,11 @@ export function isValidPlace(place) {
  * that does not exist rather than becoming the operator's checkout.
  */
 export function worktreePath(baseDir, place) {
-  return isSafePathSegment(place) ? join(baseDir, 'sessions', place) : null;
+  if (!isSafePathSegment(place)) return null;
+  const home = join(baseDir, 'sessions', place);
+  const state = readRepositoryPlace(home);
+  const primary = state?.repositories.find((r) => r.id === state.primary && r.writable);
+  return primary ? join(home, primary.folder) : home;
 }
 
 /**
@@ -290,5 +295,21 @@ export function createWorkPlaces({ repoRoot, baseDir, baseRef, onRepoChanged })
     }
   };
 
-  return { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath };
+  /**
+   * WHEN `git worktree add` CUT THIS WORKTREE: its private git dir's
+   * `commondir`, written once at creation and left alone by commits, lock,
+   * repair and move. A recreated worktree is a new birth. Null for the
+   * checkout (no such file) and for anything unreadable — read by the
+   * artifact reporter, which then has no evidence a place held older rows.
+   */
+  const worktreeBornAt = (wt) => {
+    const path = sessionMetaPath(wt, 'commondir');
+    try {
+      return path ? statSync(path).mtimeMs : null;
+    } catch {
+      return null;
+    }
+  };
+
+  return { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath, worktreeBornAt };
 }

package/bin/lib/workRetire.mjs

@@ -14,6 +14,7 @@ import { git, isSafePathSegment } from './git.mjs';
 import { PERSON_PLACE_PREFIX } from './workPlaces.mjs';
 
 export function createWorkRetire({
+  repositoryPlaces,
   repoRoot,
   baseDir,
   baseRef,
@@ -113,6 +114,10 @@ export function createWorkRetire({
         // Uncommitted work is the human's — a resource sweep does not outrank
         // it, closed tab or not. (The non-force remove would refuse anyway;
         // the explicit check keeps the intent legible.)
+        if (repositoryPlaces?.stateFor(id)) {
+          if (repositoryPlaces.remove(id)) { workTokens.delete(id); removed++; }
+          continue;
+        }
         if (git(['status', '--porcelain'], wt) !== '') continue;
         git(['worktree', 'remove', wt], repoRoot); // non-force
         workTokens.delete(id);