flowviant 0.125.7 → 0.125.12

package/README.md

@@ -67,7 +67,7 @@ The binary and global npm installs update when idle. The binary fetches the rele
 | `flowviant login` | Connect this repo to a project (approve the link it prints) |
 | `flowviant stop` | Stop every flowviant daemon on this computer |
 | `flowviant status` | Each project connected here: repo, running/serving, live agents |
-| `flowviant logs [-f]` | This repo's daemon log (`-f` follows it) |
+| `flowviant logs [-f] [-n <lines>] [--turn <id>] [--project <name|id>]` | Replay or follow retained local diagnostics; optionally select one turn |
 | `flowviant open` | Open this project's board in the browser |
 | `flowviant projects` | Every stored login and the repo it serves |
 | `flowviant machines` | Every computer serving your projects; a menu on a terminal |
@@ -76,6 +76,85 @@ The binary and global npm installs update when idle. The binary fetches the rele
 | `flowviant clean` | Delete kept agent worktrees |
 | `flowviant uninstall` | Remove every copy (`--purge` for logins too) |
 
+## Native activity feed
+
+`flowviant` (or `flowviant start`) defaults to an append-only chronological
+feed. Each work record carries its observation time, readable work name and
+stable `@` turn label; observed native children keep their parent turn and a
+child label. Long names and routine labels are shortened to fit ordinary
+terminals; errors and questions keep their actual words and line breaks.
+
+Starts, failures, interruptions, plan proposals and validated agent deliveries
+appear immediately. A delivery says **Delivered for review**; only the merge
+lane's measured landing says **Merged on the base branch**. Questions retain
+their text and the existing app destination. Answer them in Flowviant.
+Connection failures and recovery, serving changes and stopping remain visible.
+
+Routine narration and tool activity are summarized as **Latest activity**
+every ten seconds while fresh activity arrives, and flushed before immediate
+observations or at close. A quiet interval prints nothing. A latest observation
+is not proof that a command is still running. At most 256 pending turn/child
+labels are held, each limited to 120 characters; reaching that bound flushes
+them in observation order. This is a feed, not a live dashboard; `flowviant
+status` remains the on-demand snapshot.
+
+Use `flowviant --detail` or `flowviant start --detail` to print each runtime
+activity as it arrives. This selects the existing detailed activity stream;
+fuller supplied narration and tool data are available through logs below.
+The choice survives inline login, PATH adoption and self-update relaunches.
+It is inherited for that launch, not saved as a project preference. A service
+can set `FLOWVIANT_OUTPUT=detail`; `--detail` also works on `flowviant login`.
+Both presentations capture the same diagnostic detail before rendering.
+Legacy idle snapshots stay in retained diagnostics in compact mode.
+Environment-token launches attach the project journal when the roster first
+identifies the project, before starting its CLI work. If
+retention is unavailable or a write fails, the live record stays detailed.
+
+## Local diagnostic detail
+
+`flowviant logs` shows the last 80 retained lines for this repo's project,
+including daemon diagnostics and native CLI detail. Use `-n 300` for more lines,
+`-f` or `--follow` for new lines across rotation and daemon restarts, and
+`--project <name|id>` for another connected project. To isolate concurrent work,
+copy the `@` turn label from the compact feed (or the full `turn` id from detail):
+
+```sh
+flowviant logs --turn @<label> -n 300
+flowviant logs --turn <turn-id> --follow --project <name-or-id>
+```
+
+The filter accepts an exact full turn id or the deterministic twelve-hex `@`
+SHA-256 label of that id. It includes observed native children and excludes
+unattributed daemon diagnostics. With no filter those diagnostics remain
+visible. Replay includes the current log and its one predecessor, oldest first.
+Each project retains **two files of at most 2 MiB each**, under
+`~/.flowviant/daemon-<project-hash>.log` and `.log.1`, with mode `0600`.
+Retention is by bytes, not a guaranteed duration; older detail expires as work
+continues. New log directories use mode `0700`.
+
+Native entries retain observed timestamps, readable work names, full work/turn
+ids and available native-child ids, with supplied narration, answers, tool
+calls/results and CLI stderr/errors. This is **local diagnostic detail, not a
+complete vendor transcript**: it contains no unavailable reasoning or raw
+vendor event archive, and only tool information the adapters expose. Each
+encoded native record is capped at **64 KiB**, after redaction; a clipped entry
+carries `[truncated: local detail record exceeded 64 KiB]`. Oversized legacy
+console entries carry `[truncated]`. Tail limits, detected rotation/write gaps,
+unreadable records and missing selected-turn detail are explicit. A missing
+turn may have expired or predate this capture; it does not mean the turn did
+not run.
+
+Capture is independent of app trace uploads and foreground presentation. Local
+storage and replay use the daemon's existing learned-secret and credential-shape
+scrubber, with its documented exemptions; supplied per-turn MCP/login values
+are masked too. Known multiline secret fragments and streamed PEM bodies are
+masked before storage. Terminal controls are removed at storage and replay.
+Unknown secrets outside those sources/shapes remain outside that guarantee.
+If storage fails, work continues, the daemon reports that detail could not be
+retained, and a successful later write marks the gap. Foreground presentation
+never changes retained detail; desktop `--json-events` still reserves stdout for
+machine events and writes human output to stderr.
+
 ## Uninstall
 
 `flowviant uninstall` stops local daemons and removes installed copies. It keeps logins and local state in `~/.flowviant`, so reinstalling resumes them. Use `flowviant uninstall --purge` to disconnect this box from stored projects and delete that local data too. Add `--yes` to skip confirmation.

package/bin/cli.mjs

@@ -115,6 +115,11 @@ if (process.argv[2] === '__hook') {
 // is that the login ended; wait for stdout to drain before exiting.
 const flushStdout = () => new Promise((resolve) => process.stdout.write('', resolve));
 
+// Preserve an explicit foreground choice across login, PATH and update
+// relaunches, including paths that build fresh argv. No setting is saved.
+const { outputMode, configureActivityOutput } = await import('./lib/activityFeed.mjs');
+process.env.FLOWVIANT_OUTPUT = outputMode(process.argv.slice(2), process.env);
+
 // `flowviant start` is the spelled-out form of a bare `flowviant`; everything
 // below reads the start path from argv, so the word is simply dropped.
 if (process.argv[2] === 'start' && !process.argv.slice(3).some((arg) => arg === '--help' || arg === '-h')) process.argv.splice(2, 1);
@@ -229,7 +234,7 @@ async function statusCommand() {
 async function logsCommand() {
   const { runLogs } = await import('./lib/views.mjs');
   await runLogs(process.argv);
-  process.exit(0);
+  process.exit(process.exitCode || 0);
 }
 
 // `flowviant open` — this repo's board, in the browser.
@@ -484,4 +489,5 @@ const { installDaemonLogging } = await import('./lib/daemonLogging.mjs');
 const { daemonLogPath } = await import('./lib/daemonState.mjs');
 const logProjectId = CREDENTIAL?.entry?.projectId;
 installDaemonLogging(logProjectId ? daemonLogPath(logProjectId) : null, { jsonEvents: process.argv.includes('--json-events') });
+configureActivityOutput(process.env.FLOWVIANT_OUTPUT);
 await runFleetDaemon({ afterLock });

package/bin/lib/activityFeed.mjs

@@ -0,0 +1,69 @@
+/** Local foreground presentation. Retention happens before this sink. Unknown
+ * or failed retention always falls back to the complete detailed live record.
+ * A timer consumes fresh observations; it never infers liveness from silence.
+ */
+import { createHash } from 'node:crypto';
+import { c, stamp } from './ui.mjs';
+import { printableLine, printableText } from './printable.mjs';
+
+export const turnToken = id => '@' + createHash('sha256').update(id).digest('hex').slice(0, 12);
+export const matchesTurn = (id, selection) => selection === id || selection === turnToken(id);
+export const outputMode = (argv, env) => argv.includes('--detail') || env.FLOWVIANT_OUTPUT === 'detail' ? 'detail' : 'compact';
+const routine = new Set(['think', 'say', 'bash', 'glob', 'list', 'plan', 'read', 'search', 'tool', 'write']);
+
+export function formatActivityRecord(record) {
+  const name = printableLine(printableText(record.name), 24);
+  const child = record.agentId ? ` child=${turnToken(record.agentId)}` : '';
+  const prefix = `${stamp(record.observedAt)} ${c.cyan(`[${printableLine(record.kind, 16)} ${name} ${turnToken(record.turnId)}${child}]`)} `;
+  const body = printableText(record.text).replace(/\n$/, '');
+  return body.split('\n').map(line => prefix + line).join('\n') + '\n';
+}
+
+export function createActivityFeed({ intervalMs = 10_000, maxPending = 256,
+  schedule = setTimeout, cancel = clearTimeout } = {}) {
+  const pending = new Map();
+  let timer = null;
+  const flush = () => {
+    if (timer !== null) { cancel(timer); timer = null; }
+    const rows = [...pending.values()];
+    pending.clear();
+    for (const { record, write } of rows) {
+      // Only the label is coalesced. Full text was already retained, including
+      // tools/results. Observation time belongs to the latest supplied event.
+      const latest = { ...record, text: `Latest activity: ${printableLine(record.text, 120)}` };
+      write(formatActivityRecord(latest), latest.source, latest, true);
+    }
+  };
+  return {
+    present(record, detail, retained, write) {
+      if (retained === true && record.source === 'activity' && routine.has(record.activityKind)) {
+        const key = JSON.stringify([record.turnId, record.agentId]);
+        pending.delete(key); // Map order is the order of the latest observations.
+        pending.set(key, { record: { ...record, text: printableLine(record.text, 120) }, write });
+        if (pending.size >= maxPending) flush();
+        else if (timer === null) { timer = schedule(flush, intervalMs); timer.unref?.(); }
+        return;
+      }
+      // A question/error/outcome is immediate, after older pending activity.
+      flush();
+      write(retained === true ? formatActivityRecord(record) : detail, record.source, record, retained);
+    },
+    flush,
+    close(turnId) {
+      if ([...pending.values()].some(row => row.record.turnId === turnId)) flush();
+    },
+  };
+}
+
+let feed = null;
+export const compactOutput = () => feed !== null;
+export function configureActivityOutput(mode) {
+  feed?.flush();
+  feed = mode === 'compact' ? createActivityFeed() : null;
+}
+export const flushActivityOutput = () => feed?.flush();
+export const closeActivityTurn = turnId => feed?.close(turnId);
+export function presentTurnRecord(record, detail, retained, write) {
+  if (feed) feed.present(record, detail, retained, write);
+  else write(detail, record.source, record, retained);
+}

package/bin/lib/agentMergeReports.mjs

@@ -0,0 +1,46 @@
+/** Persist an outcome before sending it. Uncertain acknowledgement retries the
+ * receipt, never the Git operation; the original lease instance survives restart. */
+import { join } from 'node:path';
+import { createReportJournal } from './reportJournal.mjs';
+import { fleetRequest } from './fleetPost.mjs';
+import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
+import { FLEET_URL, DAEMON_INSTANCE } from './config.mjs';
+
+export function createMergeReports({ baseDir, delivered = async () => {} }) {
+  const journal = createReportJournal(join(baseDir, 'agent-merge-reports'));
+  const pending = new Map(journal.load().work.filter(([id, held]) =>
+    held?.body?.agentId === id && typeof held.body.ok === 'boolean' && typeof held.body.instance === 'string'));
+  const sending = new Set();
+  const retryAt = new Map();
+  const save = () => journal.save(pending, new Map());
+  const send = async (id) => {
+    if (sending.has(id) || (retryAt.get(id) ?? 0) > Date.now()) return false;
+    const held = pending.get(id);
+    if (!held) return true;
+    sending.add(id);
+    try {
+      const r = await fleetRequest(fleetEndpoint('agent-merge-done', FLEET_URL), { body: held.body });
+      // A parsed receipt includes already-settled/lost-holder results. Auth,
+      // HTML, malformed JSON and deploy skew retain the exact body.
+      if (r.ok && r.json?.success === true && typeof r.json?.data?.settled === 'boolean') {
+        pending.delete(id);
+        retryAt.delete(id);
+        save();
+        await delivered(held, r.json.data.settled);
+        return true;
+      }
+      retryAt.set(id, Date.now() + (r.retryAfterMs ?? (isConsideredRefusal(r.status) ? 60_000 : 1000)));
+      return false;
+    } finally { sending.delete(id); }
+  };
+  return {
+    pending,
+    async report(body, meta = {}) {
+      const id = String(body.agentId);
+      pending.set(id, { body: { ...body, instance: DAEMON_INSTANCE }, ...meta });
+      save();
+      return send(id);
+    },
+    async flush() { for (const id of [...pending.keys()]) await send(id); },
+  };
+}

package/bin/lib/agentMergeResolution.mjs

@@ -0,0 +1,48 @@
+/** Evidence belongs to the failed attempt, so an answer after committing can
+ * verify the same repair without inventing another commit. */
+import { readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { git, isAncestor } from './git.mjs';
+
+const marker = (wt) => resolve(wt, git(['rev-parse', '--git-path', 'flowviant-merge-resolution'], wt));
+const sha = (value) => typeof value === 'string' && /^[a-f0-9]{40,64}$/.test(value);
+
+export function gitReportedConflict(error, wt) {
+  if (/^CONFLICT \(/m.test(`${error?.stdout ?? ''}\n${error?.stderr ?? ''}`)) return true;
+  try {
+    return Boolean(git(['diff', '--name-only', '--diff-filter=U'], wt) || git(['rev-parse', '--verify', 'MERGE_HEAD'], wt));
+  } catch { return false; }
+}
+
+export function clearMergeFailure(wt) {
+  try { rmSync(marker(wt), { force: true }); } catch { /* no marker */ }
+}
+
+export function recordMergeFailure(wt, base, conflict) {
+  try {
+    writeFileSync(marker(wt), JSON.stringify({ before: git(['rev-parse', 'HEAD'], wt), base: git(['rev-parse', base], wt), conflict }));
+  } catch { clearMergeFailure(wt); }
+}
+
+export function measuredMergeResolution(wt, before, base) {
+  let start;
+  try { start = JSON.parse(readFileSync(marker(wt), 'utf8')); }
+  catch (error) {
+    if (error?.code !== 'ENOENT') return false;
+    start = { before, base: (() => { try { return git(['rev-parse', base], wt); } catch { return null; } })(), conflict: true };
+  }
+  if (!sha(start?.before) || !sha(start?.base) || typeof start.conflict !== 'boolean') return false;
+  try {
+    const tip = git(['rev-parse', 'HEAD'], wt);
+    if (git(['status', '--porcelain', '--untracked-files=no'], wt)) return false;
+    if (gitReportedConflict(null, wt)) return false;
+    git(['merge-base', '--is-ancestor', start.before, tip], wt);
+    git(['cat-file', '-e', `${start.base}^{commit}`], wt);
+    // Base may have advanced since landing; ancestry still observes that work
+    // on base without inventing another commit or trusting an absent marker.
+    if (isAncestor(tip, base, wt)) return true;
+    if (start.conflict && tip === start.before && tip !== start.base) return false;
+    git(['merge-base', '--is-ancestor', start.base, tip], wt);
+    return true;
+  } catch { return false; }
+}

package/bin/lib/agentPlan.mjs

@@ -1,3 +1,4 @@
+import { parseTestFindings } from './testFindings.mjs';
 /**
  * READING A MODEL'S ANSWER, in the agent lane's shapes: a planner's
  * PROPOSAL, an agent's own TURN RESULT and the AI pre-review's TRIAGE. The
@@ -48,8 +49,12 @@ function extract(raw) {
 
 export function parseProposal(text, scrub = envScrub) {
   const raw = String(text ?? '');
-  const parsed = extract(raw);
-  if (!parsed) return null;
+  const found = extract(raw);
+  if (!found) return null;
+  // A model says "none" with null as often as with []: both are an absent key,
+  // never a malformed list that throws the whole plan away.
+  const parsed = { ...found };
+  for (const key of ['dependencies', 'collisions', 'evidence', 'repos']) if (parsed[key] === null) delete parsed[key];
 
   const agents = [];
   for (const [i, g] of parsed.agents.slice(0, MAX_AGENTS).entries()) {
@@ -260,6 +265,13 @@ export function parseTurnResult(text, scrub = envScrub) {
         ...(typeof v.mergeOrderReason === 'string' ? { mergeOrderReason: clean(v.mergeOrderReason, 1000) } : {}),
         ...(Array.isArray(v.mergeOrders) ? { mergeOrders: v.mergeOrders.slice(0, 60) } : {}),
         answer: typeof v.summary === 'string' ? scrub(v.summary) : '',
+        ...(typeof v.verification === 'string' && v.verification.trim()
+          ? { verification: scrub(v.verification.trim()) } : {}),
+        ...(typeof v.handover === 'string' && v.handover.trim()
+          ? { handover: scrub(v.handover.trim()) } : {}),
+        ...(typeof v.automation === 'string' && v.automation.trim()
+          ? { automation: scrub(v.automation.trim()) } : {}),
+        ...(parseTestFindings(v.testFindings, scrub) ? { testFindings: parseTestFindings(v.testFindings, scrub) } : {}),
         ...progressOf(v, scrub),
         raised: Array.isArray(v.raised)
           ? v.raised

package/bin/lib/agentTaskTypes.mjs

@@ -41,31 +41,34 @@ export const AGENT_TASK_TYPES = Object.freeze({
     label: 'Bug fix',
     kind: 'code',
     contract:
-      'reproduce it first, with a failing test where the repository has tests, then make that test pass.',
+      'reproduce it first, with a failing test where the repository has tests, then make that test pass; ' +
+      'retain reproduction and before/after evidence in verification, including unverified limits.',
   }),
   tests: Object.freeze({
     label: 'Tests',
     kind: 'code',
     contract:
       'add tests for code that already exists and change no production code; if a test exposes a bug, ' +
-      'say so in your summary instead of fixing it.',
+      'report reproducible testFindings for human selection instead of fixing it.',
   }),
   refactor: Object.freeze({
     label: 'Refactor',
     kind: 'code',
-    contract: 'behaviour must not change; if an existing test would have to change, stop and ask.',
+    contract: 'behaviour must not change; if an existing test would have to change, stop and ask; ' +
+      'retain behaviour invariants and evidence in verification, including unrun checks.',
   }),
   infra: Object.freeze({
     label: 'Infra & deploy',
     kind: 'code',
-    contract: 'change the configuration in the repository; never run a deploy or touch a live environment.',
+    contract: 'change the configuration in the repository; never run a deploy or touch a live environment; ' +
+      'include rollout, rollback, required inputs and verification in handover for a human to execute.',
   }),
   automation: Object.freeze({
     label: 'Automation',
     kind: 'code',
     contract:
-      "add the scheduled job to the repository (a CI schedule, or a script and its schedule) so it runs " +
-      "where the repository's CI runs; do not run it.",
+      'add the job and its schedule to the repository; retain schedule/timezone, trigger, runner, ' +
+      'side effects, retries and notifications in automation; do not run it.',
   }),
   review: Object.freeze({
     label: 'Code review',
@@ -82,7 +85,8 @@ export const AGENT_TASK_TYPES = Object.freeze({
   prototype: Object.freeze({
     label: 'Prototype',
     kind: 'design',
-    contract: 'make every control in the flow work, with realistic sample data, in the one page.',
+    contract: 'make every control in the flow work, with realistic sample data, in the one page; ' +
+      'identify sample data, simulated actions and mocked integrations; never perform real external side effects.',
   }),
   slides: Object.freeze({
     label: 'Slides',

package/bin/lib/artifactContracts.mjs

@@ -328,6 +328,14 @@ WHAT TO DO:
    no notes, no scripts, no discarded variants. Keep each file under
    ${IMAGE_CAP_WORDS}; if one is larger, save it as WebP or at a smaller size.
 
+   For a selected-image revision, read the exact retained input and use the
+   native image EDIT capability with those bytes/reference. Preserve the requested
+   size, crop/transparency and style, and explicit replacement/retention choices.
+   Keep retained alternatives under their existing names; a new output alone
+   discards nothing. Never regenerate a similar picture, switch to a newer file,
+   or stage another output kind. If native editing is unavailable or fails,
+   relay its actual limitation/error and stop for a decision.
+
    ${NO_WINDOW} Look at a picture through your own tools,
    never an image viewer.
 

package/bin/lib/artifactIteration.mjs

@@ -180,3 +180,21 @@ export function iterationInstructions(stored) {
     `Write a fresh declaration containing only this turn's changes. Keep the declaration out of git. ` +
     `Do not claim remote deletion succeeded yourself: the daemon reports any cleanup failure.`;
 }
+
+/** Retention is bound to the measured stored version, never just its name.
+ * Every unselected file is protected; only explicit selected-version discards
+ * may retire. An older selection cannot replace a newer same-name image. */
+export function imageRevisionProtection(stored, policy) {
+  if (!policy) return new Set();
+  if (!Array.isArray(stored)) throw new Error('The image revision inventory is unavailable; retained alternatives were not changed.');
+  const allowed = [...(policy.replaceSource ? [policy.source] : []), ...policy.discard];
+  return new Set(stored.filter(row => !allowed.some(p => p.id === row.id && p.sha256 === row.sha256)).map(row => row.name));
+}
+export function imageRevisionInstructions(policy, inputs) {
+  if (!policy) return '';
+  const file = inputs?.find(f => (f.artifactId === policy.source.id || f.library?.id === policy.source.id) && f.sha256 === policy.source.sha256);
+  if (!file) throw new Error('The selected image revision has no exact retained input.');
+  return `SELECTED IMAGE EDIT INPUT: .flowviant/inputs/${file.contextId}/${file.name} (SHA-256 ${file.sha256}). Read this exact file before editing with your native image edit tool. Never choose a newest image or generate a stand-in. If this CLI/tool cannot edit these bytes, stop and relay the actual error for a decision. Size, crop, transparency, style and retention choices are in the retained context. ` +
+    (policy.replaceSource ? 'The person chose replacement of this selected version only; declare its old-to-new relationship after writing the replacement. ' : 'Keep the original image and use a distinct new output filename. ') +
+    `Only these explicit alternative discards are authorized: ${JSON.stringify(policy.discard)}. Every other stored file is retained. Do not delete or overwrite retained alternatives. A new image alone discards nothing.`;
+}

package/bin/lib/artifactReporter.mjs

@@ -40,7 +40,7 @@
 import { artifactStoredName } from './artifacts.mjs';
 import { fleetHeaders } from './fleetPost.mjs';
 import {
-  iterationSignature, iterationChanges, deletedArtifacts, localArtifact, discardLocalArtifact, iterationInstructions,
+  imageRevisionProtection, iterationSignature, iterationChanges, deletedArtifacts, localArtifact, discardLocalArtifact, iterationInstructions,
   presentArtifacts, readSeenArtifacts, writeSeenArtifacts, seenArtifacts, serverBornAt,
 } from './artifactIteration.mjs';
 import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
@@ -229,8 +229,17 @@ export function createArtifactReporter({
   const report = async ({ placeDir, before, sessionId, agentId, turnId, idle = false, requireStored = false, includeNames = null }) => {
     if (!placeDir || (!sessionId && !agentId)) return 0;
     const changes = iterationChanges(placeDir, before);
+    const protectedNames = imageRevisionProtection(before?.stored, before?.imageRevision);
+    // Forget ownership of absent retained copies, so a later idle sweep cannot
+    // reinterpret this revision's protected absence as an implicit discard.
+    if (before?.imageRevision) {
+      const present = presentArtifacts(placeDir) ?? new Set();
+      writeSeenArtifacts(seenPath(placeDir, sessionId ?? agentId), [...(before.seen ?? [])].filter(name => !protectedNames.has(name) || present.has(name)));
+      before.seen = new Set([...(before.seen ?? [])].filter(name => !protectedNames.has(name) || present.has(name)));
+      for (const name of [...changes.remove, ...Object.keys(changes.replace)]) if (protectedNames.has(name)) throw new Error(`Image revision retained ${name}; its discard or replacement was not authorized.`);
+    }
     if (!before?.stored && (changes.remove.length || Object.keys(changes.replace).length)) throw new Error('Stored artifact inventory could not be measured; removal was not attempted.');
-    const removing = new Set([...changes.remove, ...Object.keys(changes.replace), ...(before?.stored ? deletedArtifacts(placeDir, before) : [])]);
+    const removing = new Set([...changes.remove, ...Object.keys(changes.replace), ...(before?.stored ? deletedArtifacts(placeDir, before).filter(name => !protectedNames.has(name)) : [])]);
     const stored = new Map((before?.stored ?? []).map((a) => [a.name, a]));
     for (const name of [...changes.remove, ...Object.keys(changes.replace)]) {
       if (!stored.has(name)) throw new Error(`No stored artifact named ${name} belongs to this conversation.`);
@@ -253,6 +262,10 @@ export function createArtifactReporter({
         if (requireStored) failures.push(`artifact ${entry.name} could not be read; it was not delivered`);
         continue;
       }
+      if (protectedNames.has(body.fields.name)) {
+        if (body.fields.sha256 !== stored.get(body.fields.name)?.sha256) failures.push(`Image revision retained ${body.fields.name}; use a different output filename.`);
+        continue;
+      }
       if (body.withheld) {
         log(`artifact ${entry.name}: not uploaded — it contains the value of ${body.withheld} from this machine's environment`);
         if (stored.has(body.fields.name)) failures.push(`artifact ${body.fields.name} replacement was withheld; its predecessor was retained`);
@@ -312,7 +325,7 @@ export function createArtifactReporter({
       const owned = new Set([...before.stored.map((a) => a.name), ...present, ...delivered.keys()]);
       writeSeenArtifacts(seenPath(placeDir, sessionId ?? agentId),
         [...(before.seen ?? []), ...present, ...delivered.keys()]
-          .filter((name) => owned.has(name) && !removed.has(name)));
+          .filter((name) => owned.has(name) && !removed.has(name) && (!protectedNames.has(name) || present.has(name))));
     }
     if (failures.length) throw new Error(failures.join('; '));
     return n;

package/bin/lib/claudePosture.mjs

@@ -478,6 +478,27 @@ export function researchPerm(knowledgeDir, projectMcp = []) {
 /** The list with no library — what a project that keeps none runs under. */
 export const RESEARCH_PERM = researchPerm(null);
 
+/**
+ * AN ORCHESTRATED RESEARCH CARD'S LIST (2026-10-19): the `Agent` its fence
+ * denies is allowed instead, so the gate's children can start. MEASURED on
+ * Claude Code 2.1.303 (offline): a research child inherits the parent's rules
+ * — a Write to `src/` and a `touch` were refused, `/etc/hostname` and `.env`
+ * unreadable, its PreToolUse hooks carried `agent_id` — but its Write under
+ * `.flowviant/artifacts/` landed, so the gate refuses a child's file writes
+ * (orchestrator.mjs, nativeAgentTools.mjs `write`). Every other entry stays.
+ */
+export function withNativeChildren(perm) {
+  const out = [];
+  let denying = false;
+  for (const arg of perm) {
+    if (arg.startsWith('--')) denying = arg === '--disallowedTools';
+    if (denying && arg === 'Agent') continue;
+    out.push(arg);
+    if (arg === '--allowedTools') out.push('Agent');
+  }
+  return out;
+}
+
 /**
  * CLAUDE'S PERMISSION LIST FOR A TURN PROFILE, by the profile's name — one
  * entry per profile Claude declares, plus plan-mode (runtimeClaude.mjs

package/bin/lib/claudeStream.mjs

@@ -100,7 +100,7 @@ export function taskPlanChanged(tasks, result) {
 }
 
 export function handleStreamLine(line, options) {
-  const { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit, onUsage, onRateLimit, onModel, subagents, tasks } = options;
+  const { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit, onUsage, onRateLimit, onModel, subagents, tasks, onDetail } = options;
   let ev;
   try {
     ev = JSON.parse(line);
@@ -118,9 +118,11 @@ export function handleStreamLine(line, options) {
   // A sidechain with no identity must never be attributed to the parent.
   if (ev.isSidechain && !agentId) return;
   subagents?.observe(ev);
+  if (ev.type === 'result' && !ev.is_error && typeof ev.result === 'string')
+    onDetail?.(ev.result, { source: 'answer', ...(agentId ? { agentId } : {}) });
   const push = (a) => {
     if (!a || !a.label) return;
-    emit(a.label + '\n');
+    emit(a.kind === 'error' ? a.full ?? a.label : a.label + '\n', { ...a, ...(agentId ? { agentId } : {}) });
     onActivity?.({ ...a, ...(agentId ? { agentId } : {}) });
   };
   if (ev.type === 'stream_event') {
@@ -198,6 +200,7 @@ export function handleStreamLine(line, options) {
         id: b.tool_use_id, result: true, isError: b.is_error === true,
         ...(agentId ? { agentId } : {}),
         output: typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.slice(0, 8).filter(x => x?.type === 'text' && typeof x.text === 'string').map(x => x.text).join('\n') : '',
+        detail: typeof b.content === 'string' ? b.content : Array.isArray(b.content) ? b.content.filter(x => x?.type === 'text' && typeof x.text === 'string').map(x => x.text).join('\n') : '',
         exitCode: ev.tool_use_result?.exit_code ?? ev.tool_use_result?.exitCode,
       });
     }
@@ -237,6 +240,13 @@ export function handleStreamLine(line, options) {
         tools: Array.isArray(ev.tools) ? ev.tools : undefined,
       });
     }
+  } else if (ev.type === 'result' && agentId && ev.is_error) {
+    // A child's failure belongs in its record, never in the parent's answer
+    // or token count. The stream's observed spawn-call id remains its owner.
+    const listed = Array.isArray(ev.errors) ? ev.errors.filter(e => typeof e === 'string' && e.trim()).join('\n') : '';
+    const msg = listed || ev.result || ev.error?.message || ev.error || ev.subtype;
+    const full = typeof msg === 'string' ? msg : JSON.stringify(msg);
+    if (full) push({ kind: 'error', label: oneLine(full), full });
   } else if (ev.type === 'result' && !agentId) {
     /**
      * WHAT THE TURN SPENT, BEFORE ANYTHING ELSE IN THIS BRANCH.
@@ -251,7 +261,10 @@ export function handleStreamLine(line, options) {
     const usage = usageFromResult(ev);
     if (usage) onUsage?.(usage);
     // The final assistant text (carries WIKI_DONE / REGROUND_DONE).
-    if (typeof ev.result === 'string') appendText(ev.result + '\n');
+    if (typeof ev.result === 'string') {
+      appendText(ev.result + '\n');
+      if (ev.is_error) push({ kind: 'error', label: oneLine(ev.result), full: ev.result });
+    }
     else if (ev.is_error || ev.subtype) {
       // A result that carries no text is a FAILED turn (a limit, a refused
       // permission, an aborted run). Under `answerFromResult` this is the only
@@ -268,7 +281,15 @@ export function handleStreamLine(line, options) {
         ? ev.errors.filter((e) => typeof e === 'string' && e.trim()).join('; ')
         : '';
       const msg = listed || ev.error?.message || ev.error || ev.subtype;
-      appendText(`${typeof msg === 'string' ? msg : JSON.stringify(msg)}\n`);
+      const text = typeof msg === 'string' ? msg : JSON.stringify(msg);
+      appendText(`${text}\n`);
+      if (ev.is_error || listed || ev.error || String(ev.subtype).startsWith('error'))
+        push({ kind: 'error', label: oneLine(text), full: listed ? ev.errors.filter(e => typeof e === 'string' && e.trim()).join('\n') : text });
+    }
+  } else if (ev.type === 'error') {
+    const text = ev.error?.message ?? ev.message;
+    if (typeof text === 'string' && text) {
+      push({ kind: 'error', label: oneLine(text), full: text });
     }
   } else if (ev.type === 'rate_limit_event') {
     /**