flowviant 0.117.0 → 0.124.0

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
@@ -54,8 +55,8 @@
  *   (and, split earlier: workDiffs, workPreviews, workPullRequests, workShip,
  *   workAgentPlans, workAgentCheck, workAgentPrecheck, workAgentReview,
  *   workAgentTurns, workAgentMerges, workProcesses; and out of workAgentTurns,
- *   SOLID F036: workAgentTurnReports, workAgentTurnExecution,
- *   workAgentTurnBegun, workAgentTurnOutcome)
+ *   SOLID F036: workAgentTurnReports, workAgentTurnExecution, workAgentTurnBegun,
+ *   workAgentTurnOutcome; the live brief: workAgentBrief, workAgentBriefRunner)
  */
 
 import { createWorkProcesses } from './workProcesses.mjs';
@@ -92,6 +93,7 @@ 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';
 
@@ -156,6 +158,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
@@ -192,7 +201,7 @@ 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 });
@@ -200,6 +209,15 @@ export function createWorkManager({
     createWorkChildren({ extraLiveTurns });
   const { agentPublished, agentRemoteAt, publishAgentBranch, fetchPublishedBranch } =
     createWorkAgentPublish({ repoRoot, gitNet });
+  const { reconcileIdleArtifacts } = createWorkArtifactReconcile({
+    artifacts,
+    placeLocks,
+    inPlace,
+    placeDir,
+    beforeArtifacts,
+    getArtifactsAccepted,
+    log: (line) => warn(line),
+  });
   const { reportSessionWorktree, reportPlaceWorktrees, burstListeners, reportWorktrees } =
     createWorkPlaceReports({
       repoRoot,
@@ -237,8 +255,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,
@@ -349,7 +368,7 @@ export function createWorkManager({
   });
   const { runReviewEntry } = createWorkAgentReview({ runCheck, runPrecheck });
 
-  const { processAgentTurnJobs, settleAgentTurns, agentTurns, agentChildren, agentReported } = createWorkAgentTurns({
+  const { processAgentTurnJobs, interruptAgentTurns, settleAgentTurns, agentTurns, agentChildren, agentReported } = createWorkAgentTurns({
     REJECT_RETRY_MS,
     baseRef,
     inPlace,
@@ -441,7 +460,7 @@ export function createWorkManager({
   return {
     flushWorkReports,
     learnPlaces,
-    processWorkTurns,
+    processWorkTurns, interruptWorkTurns,
     processShipJobs,
     processDiffJobs,
     processKillJobs,
@@ -453,8 +472,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 +485,7 @@ export function createWorkManager({
     liveTurnCount,
     processAgentPlanJobs,
     processIntakeJobs,
-    processAgentTurnJobs,
+    processAgentTurnJobs, 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

package/bin/lib/workAgentBrief.mjs

@@ -0,0 +1,92 @@
+/** A readout alongside ONE running CLI, never another worker on its branch.
+ * No events since the last snapshot means no model call. A stopped child,
+ * pause, park or lost holder prevents a call or a late result from publishing. */
+import { AGENT_BRIEF_SYSTEM, parseAgentBrief, briefModelFor } from './agentBrief.mjs';
+
+export const AGENT_BRIEF_INTERVAL_MS = 3 * 60_000;
+export const AGENT_BRIEF_FIRST_MS = 20_000;
+export const AGENT_BRIEF_INPUT_MAX = 24_000;
+export function makeAgentBrief({ runtime, model, context, summarize, post, scrub = (s) => s, models = () => [], now = Date.now,
+  setTimer = setTimeout, clearTimer = clearTimeout }) {
+  let running = false;
+  let stopped = false;
+  let timer = null;
+  let sequence = 0;
+  let consumed = 0;
+  let entries = [];
+  let flight = null;
+  let controller = null;
+  let held = null;
+  const append = (kind, data) => {
+    if (stopped || data == null) return;
+    // Scrub before trimming so a cut never turns a secret into an unrecognized prefix.
+    let text;
+    try {
+      text = (typeof data === 'string' ? scrub(data) : JSON.stringify(data, (_key, value) => {
+        // Redact decoded strings BEFORE JSON escapes quotes and newlines;
+        // otherwise a multiline secret no longer matches its learned value.
+        if (typeof value === 'string') return scrub(value);
+        if (value && typeof value === 'object' && !Array.isArray(value))
+          return Object.fromEntries(Object.entries(value).map(([key, item]) => [scrub(key), item]));
+        return value;
+      })).slice(0, 4_000);
+    } catch { return; } // an optional readout must never fail the working CLI
+    if (!text.trim()) return;
+    entries.push({ seq: ++sequence, kind, text });
+    while (entries.length > 100 || entries.reduce((sum, e) => sum + e.text.length, 0) > AGENT_BRIEF_INPUT_MAX) entries.shift();
+  };
+  const schedule = (ms = AGENT_BRIEF_INTERVAL_MS) => {
+    if (timer || stopped || !running) return;
+    timer = setTimer(() => { timer = null; void tick(); }, ms);
+    timer?.unref?.();
+  };
+  const refresh = async () => {
+    if (!running || stopped || (!held && sequence === consumed)) return;
+    // Retry a paid-for reading without paying for another. The API rechecks
+    // holder and turn in the write, and duplicate/older snapshots cannot win.
+    if (held) { if (await post(held)) held = null; return; }
+    const brain = briefModelFor(runtime, typeof model === 'function' ? model() : model, models());
+    if (!brain) return;
+    controller = new AbortController();
+    const state = await context(controller.signal);
+    if (state?.unsupported) { stopped = true; if (timer) clearTimer(timer); timer = null; return; }
+    if (stopped || !running || !state?.active || controller.signal.aborted) return;
+    // Card changes and daemon restarts do not reset the agent's three-minute
+    // cadence. Both dates came from the server, not this machine's clock.
+    if (state.brief && Date.parse(state.sourceAt) - Date.parse(state.brief.updatedAt) < AGENT_BRIEF_INTERVAL_MS) return;
+    const through = sequence;
+    const events = entries.filter((e) => e.seq > consumed);
+    if (!events.length) return;
+    const prompt = JSON.stringify({ previous: state.brief ?? null, taskId: state.taskId ?? null,
+      omittedEvents: Math.max(0, events[0].seq - consumed - 1), events: events.map(({ kind, text }) => ({ kind, text })) });
+    const out = await summarize({ runtime, ...brain, system: AGENT_BRIEF_SYSTEM, prompt, signal: controller.signal });
+    if (stopped || !running || controller.signal.aborted) return;
+    const content = parseAgentBrief(typeof out === 'string' ? out : out?.out, scrub);
+    if (!content) return;
+    consumed = through;
+    entries = entries.filter((e) => e.seq > through);
+    held = { ...content, sourceAt: state.sourceAt ?? new Date(now()).toISOString(), ...(out?.usage ? { usage: out.usage } : {}) };
+    if (await post(held)) held = null;
+  };
+  const tick = () => {
+    if (flight) return flight;
+    flight = refresh().catch(() => {}).finally(() => { flight = null; controller = null; schedule(); });
+    return flight;
+  };
+  return {
+    append, tick,
+    running(active) {
+      running = active;
+      if (active) schedule(AGENT_BRIEF_FIRST_MS);
+      else { if (timer) clearTimer(timer); timer = null; controller?.abort(); }
+    },
+    async stop() {
+      stopped = true;
+      running = false;
+      if (timer) clearTimer(timer);
+      timer = null;
+      controller?.abort();
+      await flight;
+    },
+  };
+}

package/bin/lib/workAgentBriefRunner.mjs

@@ -0,0 +1,59 @@
+/** A separate, short-lived CLI conversation using the same vendor's login.
+ * It stands in an empty scratch directory, never in the working agent's
+ * cwd-keyed resume. No project tools, no MCP, no repository instructions. */
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { runTurn } from './runTurn.mjs';
+import { runCappedTurn } from './workCappedTurn.mjs';
+import { makeAgentBrief } from './workAgentBrief.mjs';
+import { knownCodexModels } from './runtimeOfferings.mjs';
+import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
+import { fleetRequest } from './fleetPost.mjs';
+import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
+import { scrub } from './uplinkScrub.mjs';
+
+export function createAgentBriefRunner({ admit, workChildren, run = runTurn, request = fleetRequest }) {
+  return ({ agentId, turnId, runtime, model }) => {
+    const identity = { agentId, turnId, instance: DAEMON_INSTANCE };
+    return makeAgentBrief({ runtime, model, scrub, models: knownCodexModels,
+      context: async (signal) => {
+        // Node >=20, including versions before AbortSignal.any was added.
+        const abort = new AbortController();
+        const timeout = AbortSignal.timeout(15_000);
+        const cancel = () => abort.abort();
+        signal.addEventListener('abort', cancel, { once: true });
+        timeout.addEventListener('abort', cancel, { once: true });
+        if (signal.aborted) cancel();
+        try {
+          const r = await request(fleetEndpoint('agent-brief-context', FLEET_URL), { body: identity, signal: abort.signal });
+          return r.ok ? r.json?.data : isConsideredRefusal(r.status) ? { unsupported: true } : null;
+        } finally {
+          signal.removeEventListener('abort', cancel);
+          timeout.removeEventListener('abort', cancel);
+        }
+      },
+      post: async (content) => {
+        const r = await request(fleetEndpoint('agent-brief', FLEET_URL), { body: { ...identity, ...content }, timeoutMs: 15_000 });
+        return r.ok || isConsideredRefusal(r.status);
+      },
+      summarize: async ({ signal, ...turnArgs }) => {
+        if (signal.aborted || admit('churn')) return '';
+        const releaseSlot = admit.reserve();
+        let cwd = null;
+        let usage = null;
+        try {
+          cwd = mkdtempSync(join(tmpdir(), 'flowviant-brief-'));
+          const result = await runCappedTurn({ runTurn: run, workChildren, releaseSlot, signal,
+            capMs: 60_000, transcriptCwd: cwd,
+            turnArgs: { ...turnArgs, cwd, profile: 'consult', answerFromResult: true, label: '[brief]',
+              onUsage: (u) => { usage = { ...u, runtime: turnArgs.runtime }; } } });
+          return result.wedged ? '' : { out: result.out, usage };
+        } finally {
+          releaseSlot();
+          if (cwd) rmSync(cwd, { recursive: true, force: true });
+        }
+      },
+    });
+  };
+}

package/bin/lib/workAgentPlans.mjs

@@ -1,11 +1,14 @@
 /** Agent plan claims, read-only planning turns, and proposal reports. */
-import { existsSync } from 'node:fs';
+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 { gitOrNull, isSafePathSegment } from './git.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 { canRun, runtimeById, runtimeLabel } from './runtimes.mjs';
 import { detectRuntimes as defaultDetectRuntimes, pickRuntimeFor as defaultPickRuntimeFor } from './runtimeDetection.mjs';
@@ -13,7 +16,7 @@ import { brainFor } from './workBrain.mjs';
 import { runCappedTurn } from './workCappedTurn.mjs';
 import { fleetEndpoint } from './fleetWire.mjs';
 import { claimFleetLease, fleetHeaders } from './fleetPost.mjs';
-import { REPO_PLACE, worktreePath } from './workPlaces.mjs';
+import { REPO_PLACE } from './workPlaces.mjs';
 import { addUsage } from './turnUsage.mjs';
 
 export function createWorkAgentPlans({
@@ -133,56 +136,6 @@ export function createWorkAgentPlans({
   // The peer may hold it; doing nothing is the safe answer.
   const claimAgentPlan = (id) => claimFleetLease(AGENT_PLAN_CLAIM_URL, { id });
 
-  /**
-   * 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 = worktreePath(baseDir, 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 — `gitOrNull`
-       * (git.mjs) reads a failure as null. That is the honest answer and it
-       * is what the planner should be told.
-       */
-      const r = gitOrNull(args, wt);
-      if (r == null) 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];
-  };
-
   /** See `runAgentTurn` — the admission reservation, released the moment the
    *  planner's CLI exists. */
   const runAgentPlan = async (job, releaseSlot = () => {}) => {
@@ -268,20 +221,6 @@ 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 = '';
     /** The cap fired: the CLI was still running when this machine stopped it. */
@@ -294,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.
@@ -315,6 +255,12 @@ export function createWorkAgentPlans({
          * fork a read-only planner into a build tab, and being what their own
          * `claude --continue` resumed.
          */
+        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,
@@ -322,12 +268,14 @@ export function createWorkAgentPlans({
           releaseSlot,
           transcriptCwd: repoRoot,
           turnArgs: {
+            diagnosticPlanId: id,
             prompt: AGENT_PLAN_KICKOFF({
               tasks,
               liveAgents,
               agentCap: Number.isInteger(job.agentCap) && job.agentCap > 0 ? job.agentCap : 3,
             }),
-            system: SYSTEM_PLAN,
+            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',
@@ -342,6 +290,7 @@ export function createWorkAgentPlans({
             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) => {
@@ -354,11 +303,13 @@ export function createWorkAgentPlans({
         }));
       });
     } catch (e) {
+      discovery.toolLog.state = 'partial';
       await postAgentPlan({ id, error: envScrub(String(e?.message || e)).slice(0, 500), ...spent() });
       return;
     }
 
     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

package/bin/lib/workAgentPrecheck.mjs

@@ -314,10 +314,15 @@ export function createWorkAgentPrecheck({ baseRef, admit, sessionMetaPath, workC
       agentId,
       ...(headSha ? { headSha } : {}),
       ...(usage ? { usage } : {}),
+      // Named fields, never a spread of what the parser returned: a field it
+      // keeps must be passed on here as well. `criteria` rides beside the verdict
+      // and note (2026-10-10), and an older server strips it and draws the one
+      // row it always drew.
       cards: result.cards.map((cd) => ({
         taskId: cd.taskId,
         verdict: cd.verdict,
         ...(cd.note ? { note: cd.note } : {}),
+        ...(cd.criteria ? { criteria: cd.criteria } : {}),
       })),
       ...(result.overall ? { overall: result.overall } : {}),
     };