flowviant 0.125.7 → 0.125.9

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,44 @@
+/** 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 } 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 (start.conflict && tip === start.before) return false;
+    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(['merge-base', '--is-ancestor', start.base, tip], wt);
+    return true;
+  } catch { return false; }
+}

package/bin/lib/agentPlan.mjs

@@ -48,8 +48,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()) {

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') {
     /**

package/bin/lib/codexResearch.mjs

@@ -10,6 +10,7 @@ import { ensureRealSubdir, realDirState } from './ownedDirs.mjs';
 import { closeSync, constants, copyFileSync, existsSync, fstatSync, openSync, readFileSync, readSync, lstatSync, mkdirSync, readdirSync, realpathSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { prepareResearchLaunch } from './researchHandoff.mjs';
 import { versionAtLeast } from './versionOrder.mjs';
 
 const MAX_FILES = 20_000;
@@ -120,7 +121,7 @@ export function researchFence({ cwd, helper, generatedImages }) {
  * nothing. Artifact publication stays in the original worktree for the
  * existing uploader.
  */
-export function publishResearch(source, destination) {
+export function publishResearch(source, destination, inputs = new Map()) {
   if (realDirState(destination) === 'none') mkdirSync(destination, { recursive: true });
   if (realDirState(destination) !== 'dir') throw new Error('The research artifact destination is not a real directory.');
   for (const entry of readdirSync(source, { withFileTypes: true })) {
@@ -128,7 +129,7 @@ export function publishResearch(source, destination) {
     const to = join(destination, entry.name);
     const stat = lstatSync(from);
     if (stat.isSymbolicLink()) throw new Error('An isolated research output is a symlink; nothing was accepted through it.');
-    if (stat.isDirectory()) publishResearch(from, to);
+    if (stat.isDirectory()) publishResearch(from, to, inputs);
     else if (stat.isFile() && /\.md$/i.test(entry.name)) {
       if (stat.size > 2 * 1024 * 1024) throw new Error('The research Markdown output exceeds 2 MB.');
       let there = null;
@@ -139,6 +140,7 @@ export function publishResearch(source, destination) {
       }
       if (there && !there.isFile()) throw new Error('The research output would overwrite a non-file.');
       const bytes = readFileSync(from);
+      if (inputs.get(from)?.equals(bytes)) continue;
       if (there && there.size === bytes.length && readFileSync(to).equals(bytes)) continue;
       if (there) unlinkSync(to);
       writeFileSync(to, bytes, { flag: 'wx' });
@@ -146,8 +148,27 @@ export function publishResearch(source, destination) {
   }
 }
 
+// Retained context is person/source scoped. Do not make another discussion's
+// reports readable merely because they happen to stand in this worktree.
+function retainResearchInputs(dir, names, relative = '') {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const name = relative + entry.name, path = join(dir, entry.name);
+    if (entry.isDirectory()) retainResearchInputs(path, names, name + '/');
+    else if (!names.has(name)) rmSync(path, { force: true });
+  }
+}
+function rememberResearchInputs(dir, inputs = new Map()) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) rememberResearchInputs(path, inputs);
+    else if (entry.isFile() && /\.md$/i.test(entry.name)) inputs.set(path, readFileSync(path));
+  }
+  return inputs;
+}
+
 export async function runIsolatedResearch(opts, run, {
   resolveHelper = codexResearchHelper,
+  prepareLaunch = prepareResearchLaunch,
   readVersion = (helper) => execFileSync(helper, ['--version'], { encoding: 'utf8', timeout: 10_000 }),
 } = {}) {
   if (process.platform !== 'linux') throw new Error('Isolated Codex research requires Linux or WSL.');
@@ -171,11 +192,16 @@ export async function runIsolatedResearch(opts, run, {
   try {
     copyResearchView(original, snapshot);
     let knowledge = null;
-    if (opts.knowledgeDir) {
+    if (Number.isInteger(opts.researchHandoff?.knowledgeRev)) {
+      // The launch loader will build this from the held current manifest.
+      // Never copy an unmeasured/background-sync mirror into its input view.
+      knowledge = join(snapshot, '.flowviant/knowledge');
+    } else if (opts.knowledgeDir) {
       knowledge = join(snapshot, '.flowviant/knowledge');
       copyResearchView(realpathSync(opts.knowledgeDir), knowledge);
     }
     for (const dir of ['artifacts', 'tmp']) mkdirSync(join(snapshot, '.flowviant', dir), { recursive: true, mode: 0o700 });
+    if (opts.researchHandoff) retainResearchInputs(join(snapshot, '.flowviant/artifacts'), new Set(opts.researchHandoff.artifacts.filter(a => !a.unavailable).map(a => a.name)));
     const rewrite = (text) => typeof text === 'string'
       ? text.replaceAll(original, snapshot).replaceAll(opts.knowledgeDir || '\0', knowledge || '\0') : text;
     const intro = 'This fresh research turn uses an isolated read-only copy. Prior reports are available under .flowviant/artifacts/; previous CLI conversations are not resumed because they may contain host secrets. Git metadata, .env files, credential files, symlinks and personal CLI settings are omitted. Write the Markdown report only under .flowviant/artifacts/. Web search is available; shell networking is disabled. Use exec_command with shell=/bin/bash and login=false; personal shells are outside the fence.\n\n';
@@ -187,13 +213,15 @@ export async function runIsolatedResearch(opts, run, {
         throw new Error('The native generated image directory is not a real directory.');
       generatedImages = join(imageHome, 'generated_images');
     }
-    const result = await run({ ...opts, resume: false, resumeThreadId: null, resumeConversationId: null, cwd: snapshot, knowledgeDir: knowledge,
+    const prepared = await prepareLaunch({ ...opts, resume: false, resumeThreadId: null, resumeConversationId: null, adoptResumeId: null, cwd: snapshot, knowledgeDir: knowledge,
       prompt: intro + rewrite(opts.prompt), system: rewrite(opts.system),
       researchIsolation: { cwd: snapshot, helper, generatedImages } });
+    const inputs = rememberResearchInputs(join(snapshot, '.flowviant/artifacts'));
+    const result = await run(prepared);
     // Made, or found, real at publication too: every component checked again.
     if (!ensureRealSubdir(original, '.flowviant/artifacts'))
       throw new Error('The research artifact destination is not a real directory.');
-    publishResearch(join(snapshot, '.flowviant/artifacts'), join(original, '.flowviant/artifacts'));
+    publishResearch(join(snapshot, '.flowviant/artifacts'), join(original, '.flowviant/artifacts'), inputs);
     return typeof result === 'string' ? result.replaceAll(snapshot, original) : result;
   } finally { rmSync(isolation, { recursive: true, force: true }); }
 }

package/bin/lib/commandSpecs.mjs

@@ -30,10 +30,13 @@ export const COMMANDS = [
   {
     name: 'start',
     usesCheckout: true,
-    usage: 'flowviant [start] [--project <name|id>]',
+    usage: 'flowviant [start] [--detail] [--project <name|id>]',
     summary: "Serve this repo's project: run agents and Terminal tabs here. Plain `flowviant` does the same.",
     details: [
       'Run it inside the repository you connected. The first run in a new repo asks you to approve this computer.',
+      'Default: compact chronological activity, with fresh routine summaries every 10 seconds and at event boundaries.',
+      '--detail   print each runtime activity in the foreground; preserved through login and update relaunches',
+      'flowviant logs -f --turn @<label>   follow retained detail for the short turn label in the feed (full ids also work)',
       '--project <name|id>   serve that stored project instead of the one this repo is bound to',
     ],
     group: 'run',
@@ -41,9 +44,9 @@ export const COMMANDS = [
   {
     name: 'login',
     usesCheckout: true,
-    usage: 'flowviant login [--no-start]',
+    usage: 'flowviant login [--no-start] [--detail]',
     summary: 'Connect this repo to a project: approve the code in your browser, then start serving.',
-    details: ['--no-start   save the connection without starting the daemon'],
+    details: ['--no-start   save the connection without starting the daemon', '--detail     start with the detailed foreground stream'],
     group: 'run',
   },
   {
@@ -64,9 +67,9 @@ export const COMMANDS = [
   {
     name: 'logs',
     usesCheckout: true,
-    usage: 'flowviant logs [-f] [--project <name|id>]',
+    usage: 'flowviant logs [-f] [-n <lines>] [--turn <id>] [--project <name|id>]',
     summary: "The daemon's log for this repo's project.",
-    details: ['-f, --follow   keep printing new lines as they are written', '-n <lines>     how many lines to show first (default 80)'],
+    details: ['-f, --follow   keep printing new retained lines across rotation and restart', '-n <lines>     how many matching lines to show first (default 80)', '--turn <id>    select an exact full id or the @short label in the feed, including native children', '--project <name|id>   select a connected project', 'Retains the current 2 MiB log and one predecessor; older detail expires.', 'Native records keep supplied prose and tool data, at most 64 KiB each.', 'Truncation and detected gaps are marked. This is diagnostic detail, not a full transcript.'],
     group: 'look',
   },
   {

package/bin/lib/daemonJournal.mjs

@@ -0,0 +1,102 @@
+/** Bounded local diagnostic journal. Native records share the existing project
+ * log with legacy console lines. Each native record occupies one JSON line;
+ * replay renders its text, rather than presenting shortened labels as history.
+ */
+import { appendFileSync, closeSync, constants, fchmodSync, fstatSync, mkdirSync, openSync, renameSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { printableLine, printableText } from './printable.mjs';
+import { scrub } from './uplinkScrub.mjs';
+
+export const MAX_DAEMON_LOG_BYTES = 2 * 1024 * 1024;
+export const MAX_DETAIL_RECORD_BYTES = 64 * 1024;
+export const DETAIL_PREFIX = '@flowviant-detail ';
+export const DETAIL_TRUNCATED = '\n[truncated: local detail record exceeded 64 KiB]';
+export const DETAIL_GAP = '[detail gap: local log writes failed; some detail was not retained]';
+
+export const utf8Prefix = (text, bytes) => new StringDecoder('utf8').write((Buffer.isBuffer(text) ? text : Buffer.from(text)).subarray(0, Math.max(0, bytes)));
+const safe = text => printableText(scrub(printableText(scrub(String(text ?? '')))));
+
+export function encodeDetailRecord(record) {
+  const row = { v: 1, observedAt: record.observedAt, kind: printableLine(safe(record.kind), 120), name: printableLine(safe(record.name), 120),
+    workId: safe(record.workId), turnId: safe(record.turnId), source: safe(record.source),
+    ...(record.agentId ? { agentId: safe(record.agentId) } : {}), text: safe(record.text) };
+  const encode = () => DETAIL_PREFIX + JSON.stringify(row) + '\n';
+  const encoded = row.text.length <= MAX_DETAIL_RECORD_BYTES ? encode() : null;
+  if (encoded && Buffer.byteLength(encoded) <= MAX_DETAIL_RECORD_BYTES) return encoded;
+  const full = Buffer.from(row.text);
+  row.truncated = true;
+  row.text = DETAIL_TRUNCATED;
+  if (Buffer.byteLength(encode()) > MAX_DETAIL_RECORD_BYTES) throw new Error('Detail attribution exceeds the record limit');
+  let low = 0, high = Math.min(full.length, MAX_DETAIL_RECORD_BYTES);
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    row.text = utf8Prefix(full, mid) + DETAIL_TRUNCATED;
+    if (Buffer.byteLength(encode()) <= MAX_DETAIL_RECORD_BYTES) low = mid;
+    else high = mid - 1;
+  }
+  row.text = utf8Prefix(full, low) + DETAIL_TRUNCATED;
+  return encode();
+}
+
+export function decodeDetailRecord(line) {
+  if (!line.startsWith(DETAIL_PREFIX)) return null;
+  if (Buffer.byteLength(line) > MAX_DETAIL_RECORD_BYTES) return false;
+  try {
+    const row = JSON.parse(line.slice(DETAIL_PREFIX.length));
+    if (row?.v !== 1 || !Number.isFinite(row.observedAt) ||
+        !['kind', 'name', 'workId', 'turnId', 'source', 'text'].every(k => typeof row[k] === 'string') ||
+        row.agentId !== undefined && typeof row.agentId !== 'string') return false;
+    // Older/local files are untrusted at replay too. Scrub text before it is
+    // expanded into terminal lines; never revive escapes from a JSON string.
+    return { ...row, kind: printableLine(safe(row.kind), 120), name: printableLine(safe(row.name), 120),
+      workId: printableLine(safe(row.workId), Infinity), turnId: printableLine(safe(row.turnId), Infinity),
+      ...(row.agentId ? { agentId: printableLine(safe(row.agentId), Infinity) } : {}), text: safe(row.text) };
+  } catch { return false; }
+}
+
+export function createDaemonJournal(path, { onFailure = () => {} } = {}) {
+  let missed = false;
+  const append = (raw) => {
+    let fd = null;
+    try {
+      let chunk = Buffer.from(raw);
+      const tail = '\n[truncated]\n';
+      if (chunk.length > MAX_DAEMON_LOG_BYTES)
+        chunk = Buffer.from(utf8Prefix(raw, MAX_DAEMON_LOG_BYTES - Buffer.byteLength(tail)) + tail);
+      const gap = missed ? Buffer.from('\n' + DETAIL_GAP + '\n') : Buffer.alloc(0);
+      mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+      const open = () => openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600);
+      fd = open();
+      fchmodSync(fd, 0o600);
+      if (!fstatSync(fd).isFile()) throw new Error('The local log is not a regular file');
+      if (fstatSync(fd).size + gap.length + chunk.length > MAX_DAEMON_LOG_BYTES) {
+        closeSync(fd); fd = null;
+        renameSync(path, path + '.1');
+        fd = open();
+        fchmodSync(fd, 0o600);
+      }
+      // A gap is a separate bounded entry, so even a file-sized console line
+      // cannot make a recovered log exceed its cap.
+      if (gap.length && gap.length + chunk.length <= MAX_DAEMON_LOG_BYTES) appendFileSync(fd, gap);
+      else if (gap.length) {
+        appendFileSync(fd, gap); closeSync(fd); fd = null;
+        renameSync(path, path + '.1'); fd = open(); fchmodSync(fd, 0o600);
+      }
+      appendFileSync(fd, chunk);
+      missed = false;
+      return true;
+    } catch (error) {
+      if (!missed) try { onFailure(error); } catch { /* diagnostic only */ }
+      missed = true;
+      return false;
+    } finally { if (fd !== null) try { closeSync(fd); } catch { /* a log close never stops work */ } }
+  };
+  return {
+    console: text => append(safe(text) + '\n'),
+    record(record) {
+      try { return append(encodeDetailRecord(record)); }
+      catch (error) { if (!missed) try { onFailure(error); } catch { /* diagnostic only */ } missed = true; return false; }
+    },
+  };
+}