flowviant 0.117.0 → 0.124.1

package/bin/lib/trace.mjs

@@ -60,6 +60,7 @@
  */
 
 import { THINK_MARKER } from './runtimeEvents.mjs';
+import { withoutTurnDeclaration } from './turnDeclaration.mjs';
 
 /** One batch every two seconds — the discipline the tab's narrator keeps, for
  *  the same reason: a turn emits hundreds of entries and nobody is reading them
@@ -207,7 +208,8 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
      * did when a thought was 300 characters.
      */
     prose(kind, text) {
-      const t = scrub(String(text ?? ''))
+      const readable = kind === 'think' ? String(text ?? '') : withoutTurnDeclaration(text);
+      const t = scrub(readable)
         // One line ending, whatever the CLI printed.
         .replace(/\r\n?/g, '\n')
         // Spaces and tabs collapse; `\n` is deliberately excluded from the class.
@@ -216,7 +218,7 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
         .replace(/\n{3,}/g, '\n\n')
         .trim()
         .slice(0, TRACE_PROSE_CAP);
-      if (!t) return;
+      if (!t) return null;
       const k = kind === 'think' ? 'think' : kind === 'say' ? 'say' : 'note';
       /**
        * A RUN OF BARE "thinking…" IS ONE STEP, not forty.
@@ -238,9 +240,12 @@ export function makeTraceRelay({ agentId, turnId, post, scrub = (s) => s, run =
        * steps are not shown" count stays a count of steps that existed.
        */
       if (k === 'think' && t === THINK_MARKER && lastEntry?.k === 'think' && lastEntry.t === t) {
-        return;
+        return readable;
       }
       push({ k, t });
+      // The activity pulse uses this same filtering; its original compact
+      // label stands unless protocol text was removed from the full message.
+      return readable;
     },
     /** One structured tool event, exactly as `toolEventOf` built it. A tool this
      *  builder does not know returns null there and nothing is pushed here — a

package/bin/lib/turnDeclaration.mjs

@@ -0,0 +1,88 @@
+/** A final outcome is protocol, not conversation prose. Filter before trace
+ * normalization/caps; the unmodified answer still goes to parseTurnResult.
+ * Only standalone objects and JSON/unlabelled fences count. Code examples
+ * inside prose or another language's fence stay as the CLI wrote them. */
+import { jsonObjectClosers } from './agentPlan.mjs';
+
+const statuses = new Set(['delivered', 'blocked', 'prerequisite', 'nothing']);
+function declaration(body) {
+  const raw = body.trim();
+  if (!raw.startsWith('{')) return false;
+  try {
+    const value = JSON.parse(raw);
+    return value && typeof value === 'object' && !Array.isArray(value)
+      && ((Object.hasOwn(value, 'summary') && Object.hasOwn(value, 'progress'))
+        || (typeof value.status === 'string'
+          && (statuses.has(value.status) || ['summary', 'progress', 'question'].some(key => Object.hasOwn(value, key)))));
+  } catch {
+    // A truncated/invalid declaration must not fall through as an answer.
+    // Require a protocol key at the root's opening and the declared status;
+    // arbitrary malformed JSON remains useful diagnostic output.
+    return /^\{\s*"(?:status|summary|progress|question)"\s*:/.test(raw)
+      && /"status"\s*:\s*"(?:delivered|blocked|prerequisite|nothing)"/.test(raw);
+  }
+}
+
+/** Objects on their own lines, including a final object after a preamble.
+ * Skip a whole outer span before looking again; nested examples are data. */
+function bareDeclarations(raw) {
+  const closes = jsonObjectClosers(raw);
+  let kept = '', from = 0, removed = false;
+  for (let i = 0; i < raw.length; i++) {
+    if (raw[i] !== '{') continue;
+    const end = closes.get(i) ?? -1;
+    const lineStart = raw.lastIndexOf('\n', i - 1) + 1;
+    const nextLine = end < 0 ? -1 : raw.indexOf('\n', end + 1);
+    const alone = !raw.slice(lineStart, i).trim()
+      && (end < 0 || !raw.slice(end + 1, nextLine < 0 ? raw.length : nextLine).trim());
+    const finish = end < 0 ? raw.length : end + 1;
+    if (alone && declaration(raw.slice(i, finish))) {
+      kept += raw.slice(from, i); from = finish; removed = true;
+    }
+    if (end >= 0) i = end;
+    else {
+      // An unclosed outer object owns the remaining candidate. For a stray
+      // brace in prose, skip its line instead of rescanning a brace wall.
+      const newline = raw.indexOf('\n', i);
+      if (alone || newline < 0) break;
+      i = newline;
+    }
+  }
+  return removed ? kept + raw.slice(from) : null;
+}
+
+export function withoutTurnDeclaration(text) {
+  const raw = String(text ?? '');
+  const kept = [];
+  let block = [], fence = null, json = false, removed = false;
+  let prose = [];
+  const flushProse = () => {
+    const plain = bareDeclarations(prose.join('\n'));
+    if (plain !== null) { removed = true; kept.push(plain); }
+    else kept.push(...prose);
+    prose = [];
+  };
+  // Consume every fence, including other languages, in one forward pass.
+  // A nested JSON example is part of its outer code block, never a result.
+  for (const line of raw.split('\n')) {
+    if (fence) {
+      if (line.trim() === fence) {
+        if (json && declaration(block.slice(1).join('\n'))) removed = true;
+        else kept.push(...block, line);
+        block = []; fence = null;
+      } else block.push(line);
+    } else {
+      const open = line.trim().match(/^(`{3,}|~{3,})[ \t]*([\w-]*)$/);
+      if (open) {
+        flushProse();
+        fence = open[1]; json = !open[2] || open[2].toLowerCase() === 'json'; block = [line];
+      } else prose.push(line);
+    }
+  }
+  flushProse();
+  if (fence) {
+    if (json && declaration(block.slice(1).join('\n'))) removed = true;
+    else kept.push(...block);
+  }
+  return removed ? kept.join('\n').replace(/\n{3,}/g, '\n\n').trim() : raw;
+}

package/bin/lib/turnDiagnostics.mjs

@@ -0,0 +1,93 @@
+/** Local, correlated CLI lifecycle evidence. No prompts, answers, argv, token
+ * values or token fingerprints are logged. Credential metadata is remeasured
+ * at close so a refresh/rotation can be distinguished from a stale environment.
+ * Logging is best effort and rides the daemon's existing bounded private log.
+ */
+import { randomUUID } from 'node:crypto';
+import { accessSync, constants, readFileSync, realpathSync, statSync } from 'node:fs';
+import { delimiter, isAbsolute, resolve } from 'node:path';
+import { AUTH_ENV_VARS, claudeAuthContext, claudeCredentialPath } from './claudeAuth.mjs';
+import { scrub } from './uplinkScrub.mjs';
+import { printableText } from './printable.mjs';
+import { measuredRuntimeVersion } from './runtimeDetection.mjs';
+
+let active = 0;
+const authNames = (env) => AUTH_ENV_VARS.filter((name) =>
+  typeof env[name] === 'string' && env[name].trim() !== '');
+function executableFor(bin, env, cwd) {
+  const candidates = isAbsolute(bin) || bin.includes('/')
+    ? [resolve(cwd, bin)]
+    : (env.PATH ?? '').split(delimiter).map((dir) => resolve(cwd, dir, bin));
+  for (const candidate of candidates) {
+    try { accessSync(candidate, constants.X_OK); return realpathSync(candidate); } catch { /* next */ }
+  }
+  return null;
+}
+function authFor(env) {
+  const context = claudeAuthContext({ env });
+  const credentialPath = claudeCredentialPath(env);
+  let file = null;
+  try {
+    const stat = statSync(credentialPath);
+    file = { modifiedAt: new Date(stat.mtimeMs).toISOString(), inode: stat.ino };
+  } catch { /* absent or keychain: unknown */ }
+  return { ...context, configDir: env.CLAUDE_CONFIG_DIR || null, credentialPath, file };
+}
+
+export function startTurnDiagnostics(options) {
+  try { return createTurnDiagnostics(options); }
+  catch { return () => {}; }
+}
+
+function createTurnDiagnostics({ runtime, bin, env, cwd = process.cwd(), profile,
+  planId = null, args = [], version, write = (row) => console.info(`[cli-turn] ${JSON.stringify(row)}`) }) {
+  const startedAt = Date.now();
+  const turnId = randomUUID();
+  const executable = executableFor(bin, env, cwd);
+  let settingsEnv = {};
+  if (runtime === 'claude') {
+    const at = args.indexOf('--settings');
+    if (at >= 0) {
+      try {
+        const input = args[at + 1];
+        const settings = JSON.parse(input.startsWith('{') ? input : readFileSync(input, 'utf8'));
+        if (settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env)) {
+          for (const [key, value] of Object.entries(settings.env))
+            if (typeof value === 'string') settingsEnv[key] = value;
+        }
+      } catch { /* CLI settings unavailable */ }
+    }
+  }
+  const base = { turnId, runtime, profile, planId, cwd, daemonPid: process.pid,
+    uid: process.getuid?.() ?? null, platform: process.platform,
+    nodeVersion: process.version, executable, version: version ?? null,
+    runtimeMeasurement: measuredRuntimeVersion(runtime) };
+  const auth = () => {
+    try {
+      return runtime === 'claude' ? { ...authFor({ ...env, ...settingsEnv }),
+        inheritedAuthVars: authNames(env),
+        settingsAuthVars: authNames(settingsEnv) } : null;
+    } catch { return null; }
+  };
+  const emit = (row) => {
+    try {
+      // Scrub strings even in the allowlisted metadata: paths/user names are
+      // operator supplied. No environment object or error body reaches here.
+      write(JSON.parse(scrub(printableText(JSON.stringify(row)))));
+    } catch { /* diagnostics never fail a turn */ }
+  };
+  active++;
+  emit({ ...base, phase: 'start', at: new Date(startedAt).toISOString(), activeTurns: active, auth: auth() });
+  let finished = false;
+  return ({ code = null, signal = null, pid = null, output = '', spawnError = null, cliFailed = false } = {}) => {
+    if (finished) return;
+    finished = true;
+    active--;
+    const failed = cliFailed || (code !== null && code !== 0);
+    emit({ ...base, phase: 'end', at: new Date().toISOString(), durationMs: Date.now() - startedAt,
+      pid, code, signal, spawnError, activeTurns: active, auth: auth(),
+      failureKind: failed && /OAuth session expired and could not be refreshed/i.test(output)
+        ? 'oauth_refresh' : failed && /Failed to authenticate/i.test(output) ? 'authentication'
+          : spawnError ? 'spawn' : code !== null && code !== 0 ? 'cli_exit' : null });
+  };
+}

package/bin/lib/turnLock.mjs

@@ -1,22 +1,32 @@
 /**
  * THE CROSS-PROCESS TURN LOCK — the one reading of "is a CLI of ours already
- * working in this directory".
+ * working in this tab's conversation" (and, for ship, "anywhere in this
+ * directory").
  *
  * Split out of work.mjs (2026-09-26, SOLID F037). It is read by the session
  * lane before a spawn and by the ship executor before a merge, and it is pure
  * over the disk and the kernel: no manager state, so it needs no factory and
  * is tested directly (turnLock.test.mjs). The lock FILE's path is the
- * caller's (`sessionMetaPath(wt, 'flowviant-turn.lock')`); what a pid in it
- * means is this module's.
+ * caller's (`sessionMetaPath(wt, 'flowviant-turn.lock', sessionId)`); what a
+ * pid in it means is this module's.
+ *
+ * PER TAB, NOT PER DIRECTORY (2026-10-14). It was keyed by the directory alone,
+ * on the assumption that a place holds one session. Every tab a person opens
+ * shares the checkout, so the one file serialized all of their tabs: a
+ * fourteen-minute turn in one tab held a message in two others for eight
+ * minutes each. The lock guards a CONVERSATION (two CLIs resuming one held
+ * context), so it is scoped by the tab; the unscoped file is what a daemon
+ * from before this change wrote, and is still honored while its CLI lives.
  */
-import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 import { aliveAndOurs, processStartTime } from './procRegistry.mjs';
 
 /**
- * The spawn lock: the pid of the CLI currently live in this worktree. A
- * restarted daemon must not put a second Claude into a directory the orphan
- * of its previous life is still editing — two CLIs appending to one held
- * conversation is exactly the incoherence workChains prevents in-process,
+ * The spawn lock: the pid of the CLI currently live in this tab. A restarted
+ * daemon must not resume the conversation its previous life's orphan still
+ * holds — two CLIs appending to one held conversation is exactly the
+ * incoherence the synchronous start claim prevents in-process,
  * and the lock extends that guarantee across a restart. A dead pid is a
  * stale lock (removed here); a live one means "come back next poll".
  *
@@ -59,3 +69,33 @@ export const turnLockedByLivePid = (lockPath) => {
   }
   return false;
 };
+
+/**
+ * ANY TAB'S TURN IN THIS DIRECTORY — ship's question, asked of the unscoped
+ * lock path (`sessionMetaPath(wt, 'flowviant-turn.lock')`). Ship folds and
+ * merges with git in the directory every tab there shares, so a live CLI of
+ * ANY tab defers it, not only the shipping tab's own. Reads the unscoped file
+ * and every `<name>-<scope>` beside it; nothing else in the git dir. Return
+ * the holding tab's id so the waiting log names the holder, not the shipper.
+ * A legacy lock has no tab id: null is an honest unknown.
+ */
+export const placeTurnLockHolder = (placeLockPath) => {
+  if (!placeLockPath) return null;
+  const dir = dirname(placeLockPath);
+  const name = basename(placeLockPath);
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry !== name && !entry.startsWith(`${name}-`)) continue;
+    if (turnLockedByLivePid(join(dir, entry))) {
+      return { sessionId: entry === name ? null : entry.slice(name.length + 1) };
+    }
+  }
+  return null;
+};
+
+export const placeTurnLockedByLivePid = (placeLockPath) => Boolean(placeTurnLockHolder(placeLockPath));

package/bin/lib/turnProfile.mjs

@@ -26,6 +26,14 @@
  *                Claude Code's and, since 0.115.0, Codex's; image (0.114.0)
  *                is Codex's.
  *
+ * `projectMcp` (2026-10-10, the owner): whether an agent's turn under this
+ * profile mounts MCP servers — the project's reviewed base `.mcp.json` copy
+ * and, since 2026-10-11 ("the server that is running flowviant's claude HAS
+ * these MCPs yet the agents are not using them"), this machine's own CLI
+ * servers and claude.ai connectors. Every card's posture: the code card's
+ * build, and the write-up's, mockup/3D-model/deck's and image's fences. The
+ * consult, plan, wiki and plan-mode turns are not a card's and mount none.
+ *
  * Claude's permission list for each name lives beside the lists themselves
  * (`claudePermFor`, claudePosture.mjs); this module owns the vocabulary and the
  * refusals, and imports the card-kind table and the runtime registry (whose
@@ -44,10 +52,12 @@ const declaredBy = (name) =>
     .join(' or ') || 'no CLI this daemon knows';
 const article = (word) => (/^[aeiou]/i.test(word) ? 'an' : 'a');
 
-const plain = (adapterProfile) => Object.freeze({ adapterProfile, onlyOn: null, strictMcp: false });
+const plain = (adapterProfile) => Object.freeze({ adapterProfile, onlyOn: null, strictMcp: false, projectMcp: false });
+/** The kind postures that mount MCP servers (2026-10-10; image 2026-10-11). */
+const KIND_PROJECT_MCP = new Set(['design', 'research', 'image']);
 
 export const TURN_PROFILES = Object.freeze({
-  build: plain('build'),
+  build: Object.freeze({ ...plain('build'), projectMcp: true }),
   wiki: plain('wiki'),
   consult: plain('consult'),
   plan: plain('plan'),
@@ -58,6 +68,7 @@ export const TURN_PROFILES = Object.freeze({
     // wearing the word "plan".
     onlyOn: (rt) => (rt.id === 'claude' ? null : `plan mode runs on Claude Code only — not '${rt.label}'`),
     strictMcp: true,
+    projectMcp: false,
   }),
   // The kind postures: fenced to "write only the artifacts directory", and a
   // runtime that does not declare one would run its build branch instead.
@@ -73,6 +84,7 @@ export const TURN_PROFILES = Object.freeze({
             ? null
             : `${article(name)} ${name} card runs on ${declaredBy(name)} only — not '${rt.label}'`,
         strictMcp: false,
+        projectMcp: KIND_PROJECT_MCP.has(name),
       }),
     ])
   ),
@@ -83,7 +95,7 @@ export const TURN_PROFILES = Object.freeze({
 export const RETIRED_POSTURE_KEYS = Object.freeze(['wikiPerm', 'readOnly', 'planPerm', 'planMode', 'posture']);
 
 /**
- * `{ name, adapterProfile, onlyOn, strictMcp }` for a turn's options, or
+ * `{ name, adapterProfile, onlyOn, strictMcp, projectMcp }` for a turn's options, or
  * `{ error }` in words. Absent `profile` is build.
  */
 export function resolveTurnProfile(opts = {}) {

package/bin/lib/work.mjs

@@ -33,6 +33,7 @@
  *   workChildren.mjs       the live CLI children, teardown, the admission
  *   workAgentPublish.mjs   pushing and fetching an agent's branch
  *   workPlaceReports.mjs   the worktree readout: settle, burst, sweep
+ *   workArtifactReconcile.mjs an idle agent's stored delivery against its worktree
  *   workReportQueue.mjs    every settle, held and retried until delivered
  *   workSessionTokens.mjs  the per-session work credential
  *   workNarration.mjs      the tab's live line and the deferral sentence
@@ -50,17 +51,21 @@
  *   workCappedTurn.mjs     one capped read-only consult turn: its child, its slot,
  *                          its cap and its transcript — the planner, the pre-review
  *                          and intake all run one (2026-10-10)
- *   turnLock.mjs           whether a live CLI of ours holds a directory's turn
+ *   turnLock.mjs           tab pid locks; workLiveMessages.mjs — live input; workDelivery.mjs — queue
  *   (and, split earlier: workDiffs, workPreviews, workPullRequests, workShip,
  *   workAgentPlans, workAgentCheck, workAgentPrecheck, workAgentReview,
- *   workAgentTurns, workAgentMerges, workProcesses; and out of workAgentTurns,
- *   SOLID F036: workAgentTurnReports, workAgentTurnExecution,
- *   workAgentTurnBegun, workAgentTurnOutcome)
+ *   workAgentTurns, workAgentRecovery, workAgentMerges, workProcesses; and out of workAgentTurns,
+ *   SOLID F036: workAgentTurnReports, workAgentTurnExecution, workAgentTurnBegun,
+ *   workAgentTurnOutcome; repositoryPlaces + agentRepositories: multi-repo places; the live brief: workAgentBrief, workAgentBriefRunner)
  */
 
+import { trackedRepositorySetup } from './repositorySetup.mjs';
+import { createRepositoryPlaces } from './repositoryPlaces.mjs';
+import { createAgentRepositories } from './agentRepositories.mjs';
 import { createWorkProcesses } from './workProcesses.mjs';
 import { createWorkAgentMerges } from './workAgentMerges.mjs';
 import { createWorkAgentTurns } from './workAgentTurns.mjs';
+import { createAgentRecovery } from './workAgentRecovery.mjs';
 import { createWorkAgentCheck } from './workAgentCheck.mjs';
 import { createWorkAgentPrecheck } from './workAgentPrecheck.mjs';
 import { createWorkAgentReview } from './workAgentReview.mjs';
@@ -86,17 +91,19 @@ import { createWorkSessionTurns } from './workSessionTurns.mjs';
 import { createWorkRetire } from './workRetire.mjs';
 import { FLEET_URL, FLEET_TOKEN, USER_AGENT } from './config.mjs';
 import { gitNet as gitNetIn, excludeInWorktree } from './git.mjs';
-import { createLandedObserver } from './landed.mjs';
+import { createProjectLandedObserver } from './projectLanded.mjs';
 import { createPlaceLock } from './placeLock.mjs';
 import { warn } from './ui.mjs';
 import { FLOWVIANT_OWN_PATHS } from './knowledgeLibrary.mjs';
 import { buildArtifactUpload, changedSince, snapshotArtifacts } from './artifacts.mjs';
 import { createArtifactReporter } from './artifactReporter.mjs';
+import { createWorkArtifactReconcile } from './workArtifactReconcile.mjs';
 import { renderDesignPreview } from './artifactPreview.mjs';
 import { scrub as envScrub, secretIn as envSecretIn } from './uplinkScrub.mjs';
 
 export function createWorkManager({
   repoRoot,
+  repositories,
   baseDir,
   getBaseRef,
   getMcpUrl,
@@ -133,10 +140,12 @@ export function createWorkManager({
    * `origin/<branch you happened to be on>` for the life of the daemon.
    */
   const baseRef = () => getBaseRef();
+  const repositoryPlaces = repositories && createRepositoryPlaces({ repoRoot, baseDir, repositories, changed: onRepoChanged, setup: (...args) => trackedRepositorySetup(workChildren, groupKillChildren)(...args) });
+  const agentRepositories = repositories && createAgentRepositories({ repositories, places: repositoryPlaces });
   // What arrived on base, whichever road it took — observed after every beat
   // that can move origin/<base>: the sweep's fetch, a ship's push, a PR merge
   // this daemon performed. See landed.mjs for the seeding and delivery rules.
-  const landed = createLandedObserver({ repoRoot, baseRef });
+  const landed = createProjectLandedObserver({ repoRoot, baseRef, repositories });
   /**
    * THE ARTIFACT RELAY (2026-09-22, 0.94.0) — what a turn wrote under
    * `.flowviant/artifacts/`, uploaded after it. One reporter for the life of
@@ -156,6 +165,13 @@ export function createWorkManager({
     listChanged: changedSince,
     buildUpload: buildArtifactUpload,
     renderPreview: renderDesignPreview,
+    // What each place held, per owner, beside its worktree's git dir: it dies
+    // with the worktree, so a recreated one proves no discard (artifactIteration.mjs).
+    // `sessionMetaPath` and `worktreeBornAt` are declared below; both are called only once the manager is built.
+    seenPath: (dir, owner) =>
+      /^[A-Za-z0-9_-]{1,64}$/.test(String(owner)) ? sessionMetaPath(dir, 'flowviant-artifacts-seen', owner) : null,
+    // …and when that worktree was cut, so rows stored before it are never its own.
+    placeBornAt: (dir) => worktreeBornAt(dir),
   });
   /**
    * Snapshot a place's artifact directory before a CLI spawns in it — and make
@@ -191,17 +207,26 @@ export function createWorkManager({
    */
   const gitNet = (args, ms) => gitNetIn(args, repoRoot, ms);
 
-  // ── THE SESSION'S OWN HALF — built first, because the lanes below are handed it.
-  const { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath } =
+  const { placeOf, notePlace, learnPlaces, placeDir, branchAt, placeWtFor, sessionMetaPath, worktreeBornAt } =
     createWorkPlaces({ repoRoot, baseDir, baseRef, onRepoChanged });
   const { sessionGroups, noteSessionGroup, pruneSessionGroups, sessionProcesses } =
     createWorkSessionGroups({ repoRoot });
   const { workChildren, groupKillChildren, shutdownWork, liveTurnCount, liveTurns, admit } =
     createWorkChildren({ extraLiveTurns });
-  const { agentPublished, agentRemoteAt, publishAgentBranch, fetchPublishedBranch } =
+  const { agentPublished, agentRemoteAt, publishAgentBranch, stopAgentPublishing, fetchPublishedBranch, fetchPublishedBranchAsync } =
     createWorkAgentPublish({ repoRoot, gitNet });
+  const { reconcileIdleArtifacts } = createWorkArtifactReconcile({
+    artifacts,
+    placeLocks,
+    inPlace,
+    placeDir,
+    beforeArtifacts,
+    getArtifactsAccepted,
+    log: (line) => warn(line),
+  });
   const { reportSessionWorktree, reportPlaceWorktrees, burstListeners, reportWorktrees } =
     createWorkPlaceReports({
+      repositoryPlaces,
       repoRoot,
       baseRef,
       placeOf,
@@ -237,8 +262,9 @@ export function createWorkManager({
   const { fetchAttachments, fetchAgentFiles } = createWorkAttachments();
   const { sessionRuntime, agyRegistryLookup } = createWorkSessionRuntime({ sessionMetaPath });
   const { carryDirtyState } = createAdoptCarry({ sessionMetaPath });
-  const { processWorkTurns, workAnswering } = createWorkSessionTurns({
+  const { processWorkTurns, interruptWorkTurns, workAnswering } = createWorkSessionTurns({
     repoRoot,
+    baseRef,
     baseDir,
     getMcpUrl,
     getArtifactsAccepted,
@@ -276,15 +302,10 @@ export function createWorkManager({
    * which lanes share which map (workChildren: plans, review, turns; the
    * publication maps: turns and merges).
    */
-
-  const { processDiffJobs } = createWorkDiffs({
-    repoRoot,
-  });
-
+  const { processDiffJobs } = createWorkDiffs({ repoRoot });
   const { processPreviewJobs, livePreviewIds, retirePreviews, shutdownPreviews } = createWorkPreviews({
     placeDir,
   });
-
   const { processPrJobs } = createWorkPullRequests({
     placeOf,
     placeDir,
@@ -295,7 +316,6 @@ export function createWorkManager({
     landed,
     onRepoChanged,
   });
-
   const { processShipJobs } = createWorkShipper({
     inPlace,
     placeOf,
@@ -311,7 +331,6 @@ export function createWorkManager({
     shipping,
     pendingShipReports,
   });
-
   const { processAgentPlanJobs, planning } = createWorkAgentPlans({
     postBestEffort,
     baseDir,
@@ -322,7 +341,6 @@ export function createWorkManager({
     placeLocks,
     workChildren,
   });
-
   const { processIntakeJobs, intake } = createWorkIntake({
     postBestEffort,
     inPlace,
@@ -348,9 +366,9 @@ export function createWorkManager({
     workChildren,
   });
   const { runReviewEntry } = createWorkAgentReview({ runCheck, runPrecheck });
-
-  const { processAgentTurnJobs, settleAgentTurns, agentTurns, agentChildren, agentReported } = createWorkAgentTurns({
-    REJECT_RETRY_MS,
+  const processAgentRecoveryJobs = createAgentRecovery({ baseDir, repoRoot, fetchPublishedBranch: fetchPublishedBranchAsync, inPlace, placeWtFor, reportSessionWorktree });
+  const { processAgentTurnJobs, interruptAgentTurns, settleAgentTurns, agentTurns, agentChildren, agentReported } = createWorkAgentTurns({
+    agentRepositories, REJECT_RETRY_MS,
     baseRef,
     inPlace,
     baseDir,
@@ -364,15 +382,15 @@ export function createWorkManager({
     reportSessionWorktree,
     artifacts,
     runReviewEntry,
-    publishAgentBranch,
+    publishAgentBranch, stopAgentPublishing,
     admit,
     workChildren,
     agentPublished,
     agentRemoteAt,
     fetchAgentFiles,
   });
-
   const { processAgentMergeJobs, agentMerges } = createWorkAgentMerges({
+    repositoryPlaces,
     repoRoot,
     inPlace,
     baseDir,
@@ -385,10 +403,9 @@ export function createWorkManager({
     agentPublished,
   });
 
-  // Built after the agent lane: retirement stops a stopped agent's CLI, and
-  // only the agent lane knows which child that is.
+  // Retirement asks the agent lane which CLI to stop.
   const { heldSessionIds, retireWorkSessions, freshenManualPlaces } = createWorkRetire({
-    repoRoot,
+    repositoryPlaces, repoRoot,
     baseDir,
     baseRef,
     placeOf,
@@ -441,7 +458,7 @@ export function createWorkManager({
   return {
     flushWorkReports,
     learnPlaces,
-    processWorkTurns,
+    processWorkTurns, interruptWorkTurns,
     processShipJobs,
     processDiffJobs,
     processKillJobs,
@@ -453,8 +470,10 @@ export function createWorkManager({
     shutdownPreviews,
     retireWorkSessions,
     reportWorktrees,
+    reconcileIdleArtifacts,
     shutdownWork,
     workBusy,
+    runningAgentCount: () => agentTurns.size,
     // The machine's own admission answer, and what it is counting. Handed to
     // the loop so the lanes it owns — the wiki cartographer (wikiRunner.mjs) — ask the
     // same question, and so the machine snapshot can charge memory to the work
@@ -464,7 +483,7 @@ export function createWorkManager({
     liveTurnCount,
     processAgentPlanJobs,
     processIntakeJobs,
-    processAgentTurnJobs,
+    processAgentTurnJobs, processAgentRecoveryJobs, interruptAgentTurns,
     // Only the roster's stand-down calls this — a displacement, a removal or a
     // commanded stop (holder.mjs, `standDownDisplaced`); see its comment.
     // Exported rather than hooked into `shutdownWork` because the signal