flowviant 0.125.6 → 0.125.9

package/bin/lib/runtimeEvents.mjs

@@ -29,12 +29,13 @@ const oneLine = (s, n = 140) =>
  * terminal console and a one-line pulse that is overwritten every two seconds,
  * and neither can show a paragraph. The turn TRACE is a third consumer with the
  * opposite need: it is scrollback, and clipping a sentence at 140 characters
- * there is the product summarizing its own agent.
+ * there is the product summarizing its own agent. Errors also use `full` in
+ * the native daemon console (2026-10-19), preserving their words and lines.
  *
  * So a prose activity may ALSO carry `full`: the text EXACTLY as the CLI
- * emitted it, uncollapsed and unclipped. Nothing derives it and nothing but the
- * trace reads it — `label` is untouched, so the console and the pulse are
- * byte-identical to before. Absent means there was no fuller text than the
+ * emitted it, uncollapsed and unclipped. Nothing derives it. The trace and
+ * the console's errors read it; routine console activity and the pulse still
+ * read `label`. Absent means there was no fuller text than the
  * label (a tool line, a bare thinking marker), and the trace falls back to the
  * label — which is what every pre-0.87.0 daemon does for everything.
  *
@@ -367,7 +368,14 @@ function codexEventOf(ev, cwd) {
         exitCode: item.exit_code, isError: item.status === 'failed',
         output: item.aggregated_output ?? '',
       }] : null;
-      return { activity, text, ...(toolEvent ? { toolEvent } : {}), ...(isMessage ? { answer: String(item.text ?? item.message ?? '') } : {}) };
+      const mcp = (item.item_type ?? item.type) === 'mcp_tool_call';
+      const toolEvents = mcp ? [
+        ...(item.arguments !== undefined ? [[`${item.server ?? 'mcp'}.${item.tool ?? ''}`, item.arguments, { id: item.id, runtime: 'codex' }]] : []),
+        [null, {}, { id: item.id, result: true, runtime: 'codex', isError: item.status === 'failed',
+          output: item.error?.message ?? (item.result === undefined ? '' : JSON.stringify(item.result)),
+          detail: item.error?.message ?? item.result ?? '' }],
+      ] : [];
+      return { activity, text, ...(toolEvent ? { toolEvent } : {}), ...(toolEvents.length ? { toolEvents } : {}), ...(isMessage ? { answer: String(item.text ?? item.message ?? '') } : {}) };
     }
     // THE TURN'S OWN TOKEN COUNT (2026-09-24). `codex exec --json` closes a
     // turn with `turn.completed` carrying `usage` — the codex twin of Claude's
@@ -500,18 +508,19 @@ export function parseAgyLine(line, cwd) {
     const ti = su.tool_info;
     if (!ti) return null;
     const err = ti.error?.message;
+    const toolEvent = ti.name && ti.parameters !== undefined ? [ti.name, ti.parameters, { runtime: 'antigravity', ...(ti.id ? { id: ti.id } : {}) }] : null;
     // Same rule as codex's error lines: the label is the console's, `full` is
     // the trace's, and a tool error's message is exactly the kind of sentence a
     // 140-char clamp cuts the cause out of.
     if (err)
       return {
         activity: { kind: 'error', label: oneLine(err), full: String(err) },
-        text: '',
+        ...(toolEvent ? { toolEvent } : {}), text: '',
       };
     // Each tool is reported twice — once ACTIVE, once DONE — so only the
     // terminal state emits, otherwise every action appears in the thread twice.
     if (su.state && su.state !== 'DONE') return null;
-    return { activity: humanizeAgyTool(ti.name, ti.parameters ?? {}, cwd), text: '' };
+    return { activity: humanizeAgyTool(ti.name, ti.parameters ?? {}, cwd), ...(toolEvent ? { toolEvent } : {}), text: '' };
   }
   if (ev.event === 'result') {
     const r = ev.result ?? {};
@@ -521,6 +530,7 @@ export function parseAgyLine(line, cwd) {
       activity: r.error
         ? { kind: 'error', label: oneLine(r.error), full: String(r.error) }
         : null,
+      ...(typeof r.response === 'string' && r.response ? { detail: { source: 'answer', text: r.response } } : {}),
       text: `${r.response ?? ''}${r.error ? `\n${r.error}` : ''}\n`,
     };
   }

package/bin/lib/runtimeOfferings.mjs

@@ -96,7 +96,9 @@ function commandFound(command, env) {
 export function codexServerRows(servers, env = process.env) {
   const rows = [];
   for (const s of servers) {
-    if (!s || typeof s.name !== 'string' || !nameOk(s.name)) continue;
+    // `mcp list` reads the person's own config; the daemon's `flowviant`
+    // rides `-c` and is never in it, so one of that name is theirs.
+    if (!s || typeof s.name !== 'string' || !(nameOk(s.name) || s.name === 'flowviant')) continue;
     const t = s.transport && typeof s.transport === 'object' ? s.transport : {};
     const auth = typeof s.auth_status === 'string' ? s.auth_status : '';
     let status = 'configured';

package/bin/lib/startProject.mjs

@@ -208,6 +208,16 @@ export async function resolveStartProject({ dirGiven }) {
           `or connect this repo to its own project with \`${terminalCommand('login')}\`.`
       );
       process.exit(1);
+    } else if (interactive && !CREDENTIAL.choices?.length) {
+      // NOTHING STORED AND A PERSON AT THE TERMINAL IS A FIRST CONNECTION
+      // (2026-10-19). The app's connect command ends in a bare `flowviant`
+      // and the README promises "approve the code in Flowviant → connected",
+      // yet this branch printed "no credential found" and exited 1 — so the
+      // one command every first connection runs failed after a successful
+      // install. Log in here, as the picker's connect row does; headless
+      // still refuses in the words below, because nobody can approve a code.
+      console.log('No project is connected on this machine yet — connecting one now.');
+      await reexecAfterLogin();
     } else {
       console.error(
         'error: no credential found. Easiest:\n' +

package/bin/lib/turnDiagnostics.mjs

@@ -12,6 +12,7 @@ import { scrub } from './uplinkScrub.mjs';
 import { printableText } from './printable.mjs';
 import { measuredRuntimeVersion } from './runtimeDetection.mjs';
 import { VERSION } from './config.mjs';
+import { diagnostic } from './daemonLogging.mjs';
 
 let active = 0;
 const authNames = (env) => AUTH_ENV_VARS.filter((name) =>
@@ -42,7 +43,7 @@ export function startTurnDiagnostics(options) {
 }
 
 function createTurnDiagnostics({ runtime, bin, env, cwd = process.cwd(), profile,
-  planId = null, args = [], stdinBytes = 0, version, write = (row) => console.info(`[cli-turn] ${JSON.stringify(row)}`) }) {
+  planId = null, args = [], stdinBytes = 0, version, write = (row) => diagnostic(`[cli-turn] ${JSON.stringify(row)}`) }) {
   const startedAt = Date.now();
   const turnId = randomUUID();
   const executable = executableFor(bin, env, cwd);

package/bin/lib/turnOutput.mjs

@@ -0,0 +1,63 @@
+/** The human output contract for one CLI invocation. Each sink write is a
+ * complete record; no turn leaves a prefix or an unfinished line in the
+ * shared stream. `work` is local attribution, never a new machine event.
+ * Callers supply { kind, name, id, turnId }; the writer also receives the
+ * complete sanitized record as its third argument for subsequent local sinks.
+ * Its fourth argument is retention: true / failed false / unconfigured null.
+ */
+import { randomUUID } from 'node:crypto';
+import { basename } from 'node:path';
+import { format } from 'node:util';
+import { printableLine, printableText } from './printable.mjs';
+import { formatTurnRecord } from './turnRecord.mjs';
+import { retainTurnRecord } from './daemonLogging.mjs';
+import { createLocalDetailScrubber } from './uplinkScrub.mjs';
+import { closeActivityTurn, presentTurnRecord } from './activityFeed.mjs';
+
+const nameOf = (value) => printableLine(printableText(value), 120);
+const idOf = (value) => typeof value === 'string' && value ? printableLine(printableText(value), Infinity) : null;
+
+export function createTurnOutput({ work = {}, label, cwd, runtime = 'claude', mcpEnv }, {
+  now = Date.now,
+  write = (text, source) => (source === 'error' ? process.stderr : process.stdout).write(text),
+} = {}) {
+  // A lane without a server turn (wiki/pre-review/brief) gets a local
+  // invocation id. It is never presented as the CLI's native session id.
+  const redact = createLocalDetailScrubber(mcpEnv);
+  const retain = (text, meta = {}) => retainTurnRecord({ ...identity, ...meta, kind: redact.text(work.kind || (label ? identity.kind : runtime)), name: redact.text(work.name || identity.name),
+    text: printableText(meta.source === 'stderr' ? redact.stderr(text) : redact.text(text)) });
+  const runtimeName = nameOf(runtime) || 'CLI';
+  const turnId = idOf(work.turnId) || randomUUID();
+  const identity = Object.freeze({
+    kind: nameOf(work.kind) || nameOf(printableText(label)) || runtimeName,
+    name: nameOf(work.name) || nameOf(cwd ? basename(cwd) : '') || runtimeName,
+    workId: idOf(work.id) || turnId,
+    turnId,
+  });
+  const emit = (raw, { observedAt = now(), agentId, source = 'activity', full, kind: activityKind } = {}) => {
+    const text = printableText(String(raw));
+    if (!text) return;
+    const child = idOf(agentId);
+    const record = Object.freeze({ ...identity, observedAt, source, text, ...(activityKind ? { activityKind } : {}), ...(child ? { agentId: child } : {}) });
+    const retained = retain(typeof full === 'string' ? full : String(raw), { observedAt, source, ...(child ? { agentId: child } : {}) });
+    presentTurnRecord(record, formatTurnRecord(record, { label }), retained, write);
+  };
+  const tool = (name, input, meta = {}, observedAt = now()) => {
+    try {
+      const heading = meta.result ? `tool result ${meta.id || ''}${meta.isError ? ' (failed)' : ''}${meta.exitCode !== undefined ? ` exit=${meta.exitCode}` : ''}` : `tool call ${name || 'tool'}${meta.id ? ` id=${meta.id}` : ''}`;
+      // Scrub strings before JSON escaping can hide multiline secret values.
+      const value = meta.result ? meta.detail ?? meta.output ?? '' : input;
+      const data = typeof value === 'string' ? value : JSON.stringify(value, (_key, field) => typeof field === 'string' ? redact.text(field) : field, 2);
+      if (meta.result && (meta.isError === true || typeof meta.exitCode === 'number' && meta.exitCode !== 0))
+        emit(data || heading, { observedAt, agentId: meta.agentId, source: 'error' });
+      return retain(heading + '\n' + data, { observedAt, source: meta.result ? 'tool_result' : 'tool_call', ...(meta.agentId ? { agentId: idOf(meta.agentId) } : {}) });
+    } catch { return retain('[tool detail unavailable: could not serialize the supplied data]', { observedAt, source: 'tool_call' }); }
+  };
+  return {
+    identity, emit, tool,
+    event: (text, event = 'lifecycle') => emit(text, { source: event }),
+    close: () => closeActivityTurn(turnId),
+    detail: (text, meta = {}) => retain(text, { observedAt: now(), source: 'activity', ...meta }),
+    error: (error) => emit(format(error), { source: 'error' }),
+  };
+}

package/bin/lib/turnRecord.mjs

@@ -0,0 +1,11 @@
+/** One complete attributable human record. Shared by live output and replay. */
+import { c, stamp } from './ui.mjs';
+import { printableText } from './printable.mjs';
+
+export function formatTurnRecord(record, { label, color = true } = {}) {
+  const { observedAt, kind, name, workId, turnId, agentId, text } = record;
+  const lane = `[${kind}]`;
+  const prefix = `${color ? stamp(observedAt) : printableText(stamp(observedAt))} ${label || (color ? c.cyan(lane) : lane)} ${JSON.stringify(name)} work=${JSON.stringify(workId)} turn=${JSON.stringify(turnId)}${agentId ? ` child=${JSON.stringify(agentId)}` : ''} `;
+  const body = text.endsWith('\n') ? text.slice(0, -1) : text;
+  return body.split('\n').map(line => prefix + line).join('\n') + '\n';
+}

package/bin/lib/turnSubagents.mjs

@@ -23,6 +23,7 @@ import { handleStreamLine } from './claudeStream.mjs';
 import { createClaudeSubagents } from './claudeSubagents.mjs';
 import { createClaudeSubagentProgress } from './claudeSubagentProgress.mjs';
 import { createCodexSubagentReader } from './codexSubagents.mjs';
+import { humanizeClaudeTool } from './runtimeEvents.mjs';
 import { SUBAGENT_CAP } from './subagentBounds.mjs';
 
 /**
@@ -30,7 +31,7 @@ import { SUBAGENT_CAP } from './subagentBounds.mjs';
  * sinks, which a Claude child's transcript rows feed as its stream does.
  */
 export function createTurnSubagents({ runtime, cwd, since, env, owned, onSubagent, onSpawnResult, resumeThreadId,
-  sinks: { emit, onActivity, onToolEvent, appendText } }) {
+  sinks: { emit, onActivity, onToolEvent, appendText, onDetail } }) {
   // An orchestrator bounds its own records and settles them at close
   // (orchestrator.mjs). Counted here by stream id, refused retries used up
   // the 32 and later children's updates were dropped; the exit sweep
@@ -48,11 +49,20 @@ export function createTurnSubagents({ runtime, cwd, since, env, owned, onSubagen
   const claudeProgress = runtime === 'claude' && onSubagent ? createClaudeSubagentProgress({
     cwd, since, env,
     onLine: line => handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText,
-      answerFromResult: true, subagents }),
+      answerFromResult: true, subagents, onDetail }),
   }) : null;
   const codexAgents = runtime === 'codex' && onSubagent ? createCodexSubagentReader({
     since, env,
-    onSubagent: reportSubagent, onActivity, onToolEvent,
+    onSubagent: reportSubagent,
+    onActivity: (activity) => {
+      emit(activity.kind === 'error' ? activity.full ?? activity.label : activity.label + '\n', activity);
+      onActivity?.(activity);
+    },
+    onToolEvent: (name, input, meta) => {
+      const activity = humanizeClaudeTool(name, input, cwd);
+      if (activity && !meta?.result) emit(activity.label + '\n', { ...activity, ...meta });
+      onToolEvent?.(name, input, meta);
+    },
     onSpawnResult,
   }) : null;
   const resumed = runtime === 'codex' && typeof resumeThreadId === 'string' ? resumeThreadId : null;

package/bin/lib/ui.mjs

@@ -9,8 +9,8 @@ export const c = {
   blue: wrap(34), magenta: wrap(35), cyan: wrap(36), gray: wrap(90),
 };
 
-const stamp = () => {
-  const d = new Date();
+export const stamp = (observedAt = Date.now()) => {
+  const d = new Date(observedAt);
   const p = (n) => String(n).padStart(2, '0');
   return c.gray(`${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`);
 };

package/bin/lib/update.mjs

@@ -39,7 +39,7 @@ import { platform, arch } from 'node:process';
 import { pipeline } from 'node:stream/promises';
 import { Readable } from 'node:stream';
 import { relaunchSelf, runningCompiledBinary, runningViaNpx, selfArgv, terminalCommand } from './launchCommand.mjs';
-import { VERSION } from './config.mjs';
+import { DAEMON_INSTANCE, VERSION } from './config.mjs';
 import { compareVersions, versionBelow } from './versionOrder.mjs';
 import { note, ok, warn } from './ui.mjs';
 
@@ -194,6 +194,9 @@ export function reexec(teardown, { viaNpx = false, target = null } = {}, deps =
       // as a rival and the new daemon SIGTERMed this proxy. instance.mjs adopts
       // the lock from this pid when it is really an ancestor of the successor.
       FLOWVIANT_REEXEC_FROM: String(process.pid),
+      // WHO THE SUCCESSOR IS, to the server: this process's own instance, so
+      // the idle tabs' session leases are already its own (config.mjs).
+      FLOWVIANT_DAEMON_INSTANCE: DAEMON_INSTANCE,
       // WHAT WE RESTARTED IN ORDER TO BECOME. The successor compares its own
       // VERSION against this: if it came back still short, the update did not
       // take (a registry serving a stale `latest`, an npx cache that refused to
@@ -223,9 +226,20 @@ export function updateRestartFailed(target) {
   return nowVsAttempted === -1 && targetVsAttempted !== null && targetVsAttempted <= 0;
 }
 
-/** Install @latest globally. Throws on failure (EACCES without sudo, offline…). */
-function installLatest() {
-  execFileSync('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit' });
+/**
+ * HOW LONG A GLOBAL INSTALL MAY TAKE (2026-10-19). The install is synchronous
+ * — it holds the event loop for as long as npm runs — and it had no bound, so
+ * a registry or a lock that hung npm hung the whole daemon: no poll, no wake,
+ * no turn, on a machine that read as connected. Five minutes is far past a
+ * real install; past it npm is killed and the failure is the usual one,
+ * retried in fifteen minutes.
+ */
+export const INSTALL_TIMEOUT_MS = 5 * 60_000;
+
+/** Install @latest globally. Throws on failure (EACCES without sudo, offline,
+ *  past `INSTALL_TIMEOUT_MS`…). `exec` and `timeoutMs` are the test seams. */
+export function installLatest({ exec = execFileSync, timeoutMs = INSTALL_TIMEOUT_MS } = {}) {
+  exec('npm', ['install', '-g', 'flowviant@latest'], { ...npmOutsideCheckout(), stdio: 'inherit', timeout: timeoutMs, killSignal: 'SIGKILL' });
 }
 
 /**

package/bin/lib/uplinkScrub.mjs

@@ -528,3 +528,52 @@ export function secretIn(bytes) {
   }
   return null;
 }
+
+/** Local diagnostic retention has the same learned values and token shapes.
+ * A supplied per-turn MCP/login credential is known directly, even before an
+ * env rescan. stderr arrives as complete physical lines, so keep PEM masking
+ * state and mask the lines of learned multiline secrets too. This does not
+ * change uplink scrubbing or the CLI's foreground output.
+ */
+export function createLocalDetailScrubber(extraEnv = {}) {
+  const extras = Object.entries(extraEnv).filter(([name, value]) =>
+    /(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|AUTH|CAPABILITY)(?:_|$)/i.test(name) && typeof value === 'string' && value);
+  const text = raw => {
+    let out = scrub(String(raw ?? ''));
+    const known = [...values.map(v => [v.name, v.value]), ...extras].sort((a, b) => b[1].length - a[1].length);
+    for (const [name, value] of known) {
+      const pieces = value.includes('\n') ? [value, ...value.split(/\r?\n/).filter(Boolean)] : [value];
+      for (const piece of pieces) out = out.split(piece).join(`[REDACTED:${name}]`);
+    }
+    return out;
+  };
+  let privateKey = false;
+  return {
+    text,
+    stderr(raw) {
+      const value = String(raw), trailing = value.endsWith('\n');
+      const lines = value.split('\n');
+      if (trailing) lines.pop();
+      return lines.map(line => {
+        PEM_BEGIN_RE.lastIndex = 0;
+        const begin = PEM_BEGIN_RE.exec(line);
+        PEM_END_RE.lastIndex = begin ? begin.index + begin[0].length : 0;
+        const end = PEM_END_RE.exec(line);
+        if (privateKey || begin) {
+          const prefix = privateKey ? '' : line.slice(0, begin.index);
+          privateKey = !end;
+          return text(prefix + '[REDACTED:PRIVATE_KEY]' + (end ? line.slice(end.index + end[0].length) : ''));
+        }
+        return text(line);
+      }).join('\n') + (trailing ? '\n' : '');
+    },
+  };
+}
+
+/** Durable handoff fields share the portable server filter (parity checked). */
+export function filterResearchText(text) {
+  return text
+    .replace(/(\bBearer\s+)[A-Za-z0-9._~+\/-]+=*/gi, '$1[REDACTED:credential]')
+    .replace(/(["']?(?:[A-Za-z0-9_]*(?:api[_-]?key|token|secret|password|passwd|credential)|authorization)["']?\s*[:=]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;\n}]+)/gi, '$1[REDACTED:credential]')
+    .replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, '$1[REDACTED:credential]@');
+}

package/bin/lib/views.mjs

@@ -8,8 +8,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { closeSync, existsSync, openSync, readSync, statSync } from 'node:fs';
-import { StringDecoder } from 'node:string_decoder';
+import { statSync } from 'node:fs';
 import { APP_URL, FLEET_URL, USER_AGENT, VERSION } from './config.mjs';
 import { detectRepoRoot, listStoredProjects, projectLabel, resolveStoredCredential } from './credentials.mjs';
 import { desktopStatusRemote, installChannel } from './desktopContract.mjs';
@@ -17,9 +16,11 @@ import { daemonLogPath } from './daemonState.mjs';
 import { git as runGit } from './git.mjs';
 import { daemonRunningFor } from './instance.mjs';
 import { agoFrom } from './machineListing.mjs';
-import { printable, printableText } from './printable.mjs';
+import { printable, printableLine, printableText } from './printable.mjs';
 import { detectRuntimes } from './runtimeDetection.mjs';
 import { c } from './ui.mjs';
+import { createLogReader } from './logReplay.mjs';
+import { scrub } from './uplinkScrub.mjs';
 import { versionBelow } from './versionOrder.mjs';
 
 // "Behind" in these views is versionBelow (versionOrder.mjs): an unreadable
@@ -101,67 +102,57 @@ export function resolveProjectForView(argv = process.argv, cwd = process.cwd())
   };
 }
 
-/**
- * The last `count` lines of a file, read from its end — PRINTABLE (2026-10-10,
- * the audit's F133). A daemon before this release logged member-written card
- * titles raw, so a replay could carry an OSC 52 into whichever terminal runs
- * `flowviant logs`. `printableText` keeps the lines' shape; a log written on a
- * TTY loses its colours with everything else.
- */
+/** Compatibility readout over the same retained-history reader as logs -f. */
 export function tailLines(path, count) {
-  const size = statSync(path).size;
-  const want = Math.min(size, 256 * 1024);
-  const buf = Buffer.alloc(want);
-  const fd = openSync(path, 'r');
-  try { readSync(fd, buf, 0, want, size - want); } finally { closeSync(fd); }
-  const lines = printableText(buf.toString('utf8')).split('\n');
-  if (lines.at(-1) === '') lines.pop();
-  if (want < size) lines.shift(); // the first line is cut mid-way
-  return { text: lines.slice(-count).join('\n'), size };
+  const reader = createLogReader(path);
+  try { return { text: reader.snapshot(count).text, size: statSync(path).size }; }
+  finally { reader.close(); }
 }
 
-/**
- * What `logs -f` prints of each new chunk: decoded as a STREAM, because a read
- * can end inside a multi-byte character, and scrubbed like the tail. A sequence
- * split across two reads loses its ESC in the first and its terminator in the
- * second, so what is left of it is plain text.
- */
-export function createLogFollower() {
-  const decoder = new StringDecoder('utf8');
-  return (buf) => printableText(decoder.write(buf));
-}
-
-export async function runLogs(argv = process.argv) {
-  const which = resolveProjectForView(argv);
-  if (!which.entry) { console.error(which.message); process.exit(1); }
-  const path = daemonLogPath(which.entry.projectId);
+export async function runLogs(argv = process.argv, {
+  resolveProject = resolveProjectForView, pathFor = daemonLogPath,
+  write = text => process.stdout.write(text), say = text => console.error(text),
+  signal, intervalMs = 500,
+} = {}) {
+  const atTurn = argv.indexOf('--turn');
+  const turnId = atTurn >= 0 ? argv[atTurn + 1] : argv.find(a => a.startsWith('--turn='))?.slice(7) ?? null;
+  if (turnId !== null && (!turnId || turnId.startsWith('-'))) {
+    say('error: --turn needs the exact turn id printed in an activity line');
+    process.exitCode = 1; return;
+  }
+  const which = resolveProject(argv);
+  if (!which.entry) { say(which.message); process.exitCode = 1; return; }
+  const path = pathFor(which.entry.projectId);
   const at = argv.indexOf('-n');
-  const count = at >= 0 && Number(argv[at + 1]) > 0 ? Math.floor(Number(argv[at + 1])) : 80;
+  const count = at >= 0 && Number.isFinite(Number(argv[at + 1])) && Number(argv[at + 1]) > 0 ? Math.max(1, Math.floor(Number(argv[at + 1]))) : 80;
   const follow = argv.includes('-f') || argv.includes('--follow');
-  if (!existsSync(path)) {
-    console.log(`No log yet for ${projectLabel(which.entry)}. It starts when the daemon first runs: ${c.cyan('flowviant')} in its repo.`);
+  const reader = createLogReader(path, { turnId });
+  try {
+    const snapshot = reader.snapshot(count);
+    if (snapshot.text) write(snapshot.text + '\n');
+    if (!follow && snapshot.pending) say('An unfinished trailing log record was not replayed.');
+    if (snapshot.omitted) say(`Showing the last ${count} retained lines; earlier retained lines were omitted.`);
+    if (turnId !== null) {
+      if (!snapshot.matched) say(`No retained detail for turn ${printableLine(scrub(turnId), 200)}. It may have expired or predate local detail recording.${follow ? ' Waiting for new detail.' : ''}`);
+      else say('Local detail retains at most two 2 MiB files; older detail may have expired.');
+    } else if (!snapshot.found) {
+      say(`No log yet for ${projectLabel(which.entry)}. It starts when the daemon first runs: flowviant in its repo.`);
+    }
     if (!follow) return;
-  } else {
-    const { text } = tailLines(path, count);
-    if (text) console.log(text);
-  }
-  if (!follow) return;
-  // Poll rather than fs.watch: the daemon rotates the file (a rename), and a
-  // watch on the old inode would go quiet exactly then.
-  let offset = existsSync(path) ? statSync(path).size : 0;
-  const followed = createLogFollower();
-  for (;;) {
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    if (!existsSync(path)) continue;
-    const size = statSync(path).size;
-    if (size < offset) offset = 0; // rotated
-    if (size === offset) continue;
-    const buf = Buffer.alloc(size - offset);
-    const fd = openSync(path, 'r');
-    try { readSync(fd, buf, 0, buf.length, offset); } finally { closeSync(fd); }
-    process.stdout.write(followed(buf));
-    offset = size;
-  }
+    while (!signal?.aborted) {
+      await new Promise(resolve => {
+        const done = () => { clearTimeout(timer); signal?.removeEventListener('abort', done); resolve(); };
+        const timer = setTimeout(done, intervalMs);
+        signal?.addEventListener('abort', done, { once: true });
+      });
+      if (signal?.aborted) break;
+      const next = reader.poll();
+      if (next.text) write(next.text);
+    }
+  } catch (error) {
+    say(`Could not read the local log (${printableText(String(error?.code || 'read failed'))}).`);
+    process.exitCode = 1;
+  } finally { reader.close(); }
 }
 
 /** The command that opens a URL in this computer's browser. Inside WSL that is

package/bin/lib/wikiRunner.mjs

@@ -442,7 +442,7 @@ export function createWikiRunner({
               profile: 'wiki',
               vaultDir,
               runtime: wikiRt,
-              label: c.cyan('[wiki]'),
+              work: { kind: 'wiki', id: vaultDir, name: 'Wiki sweep' },
               // No skills or connectors are harvested off a wiki turn: it is
               // fenced (no settings source, strict MCP), so its init names less
               // than the machine has (runTurn.mjs, `initHarvestFor`).
@@ -492,7 +492,7 @@ export function createWikiRunner({
                 profile: 'wiki',
                 vaultDir,
                 runtime: wikiRt,
-                label: c.cyan('[wiki]'),
+                work: { kind: 'wiki', id: vaultDir, name: task.title },
                 onActivity,
                 onUsage: onUsage(wikiRt),
                 onSpawn: (ch) => {

package/bin/lib/work.mjs

@@ -27,7 +27,6 @@
  * whole — `workBusy` and the returned surface. A pure rule or constant
  * (REPO_PLACE, the resume-id guards, brainFor, the turn lock) is IMPORTED by
  * every lane that reads it, never carried through here.
- *
  *   workPlaces.mjs         where a session works, its worktree, its markers
  *   workSessionGroups.mjs  which process groups each tab started
  *   workChildren.mjs       the live CLI children, teardown, the admission
@@ -36,7 +35,7 @@
  *   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
+ *   workNarration.mjs      the tab's live line; workActivity.mjs — local outcomes and destinations
  *   workAttachments.mjs    files the human attached, brought to disk (tabs and agents)
  *   workSessionRuntime.mjs which CLI a tab speaks, which conversation resumes
  *   workAdoptCarry.mjs     adoption's dirty carry
@@ -48,6 +47,7 @@
  *   workCommandAudit.mjs   one turn's `$ …` audit, batched to the server
  *   workBrain.mjs          the model and effort a turn may put on argv (pure)
  *   workIntake.mjs         one incoming ticket drafted into a card, read-only (2026-09-28)
+ *   workPlanRecovery.mjs  read-only diagnosis and attempt cancellation
  *   workCappedTurn.mjs     one capped read-only consult turn: its child, its slot,
  *                          its cap and its transcript — the planner, the pre-review
  *                          and intake all run one (2026-10-10)
@@ -250,7 +250,7 @@ export function createWorkManager({
     flushWorkReports,
     sweepMergedSessionBranch,
   } = createWorkReportQueue({
-    repoRoot,
+    repoRoot, journalDir: baseDir,
     baseRef,
     workAttempts,
     artifacts,
@@ -261,7 +261,7 @@ export function createWorkManager({
   });
   const { workTokens, mintWorkToken } = createWorkSessionTokens({ getLeaseTtl });
   const { makeNarrator, sayTurnDeferred, lastDeferSaid } = createWorkNarration();
-  const { fetchAttachments, fetchAgentFiles } = createWorkAttachments();
+  const { fetchTabFiles, fetchAgentFiles } = createWorkAttachments();
   const { sessionRuntime, agyRegistryLookup } = createWorkSessionRuntime({ sessionMetaPath });
   const { carryDirtyState } = createAdoptCarry({ sessionMetaPath });
   const { processWorkTurns, interruptWorkTurns, workAnswering } = createWorkSessionTurns({
@@ -287,7 +287,7 @@ export function createWorkManager({
     sessionRuntime,
     agyRegistryLookup,
     carryDirtyState,
-    fetchAttachments,
+    fetchTabFiles,
     makeNarrator,
     sayTurnDeferred,
     lastDeferSaid,

package/bin/lib/workActivity.mjs

@@ -0,0 +1,65 @@
+/** Local lifecycle presentation. Inputs are the lane's validated settlement,
+ * never a phrase guessed from narration or a successful process exit.
+ */
+import { APP_URL, PROJECT_ID } from './config.mjs';
+import { createTurnOutput } from './turnOutput.mjs';
+
+export const agentWork = job => ({ kind: 'agent', id: job.agentId,
+  name: job.task?.title || job.agentName || job.agentId, turnId: job.id });
+export const sessionWork = job => ({ kind: 'tab', id: job.sessionId,
+  name: job.sessionName || job.sessionId, turnId: job.id });
+export const planWork = job => ({ kind: 'plan', id: job.id,
+  name: (Array.isArray(job.tasks) ? job.tasks : []).map(task => task?.title).filter(Boolean).join(' · ') || 'Planning', turnId: job.id });
+
+export function workDestination(work, { projectId = PROJECT_ID, appUrl = APP_URL, taskId } = {}) {
+  const safe = id => typeof id === 'string' && id && id !== '.' && id !== '..';
+  if (!safe(projectId) || !safe(work.id)) return null;
+  const base = `${appUrl}/projects/${encodeURIComponent(projectId)}`;
+  if (work.kind === 'agent') return `${base}/v2/agents/${encodeURIComponent(work.id)}${safe(taskId) ? `?${new URLSearchParams({ task: taskId })}` : ''}`;
+  if (work.kind === 'tab') return `${base}/v2/terminal?${new URLSearchParams({ tab: work.id })}`;
+  return `${base}/board`;
+}
+
+export function reportWorkOutcome(work, body, destination = workDestination(work)) {
+  const output = createTurnOutput({ work });
+  let text;
+  if (body.interrupted) text = 'Interrupted';
+  else if (body.outcome === 'question') text = `Needs input in Flowviant\n${body.answer || ''}`;
+  else if (body.outcome === 'delivered') text = 'Delivered for review';
+  else if (body.outcome === 'replied') text = 'Replied in the session';
+  else if (body.outcome === 'drafted') text = 'Ticket draft ready for review';
+  else if (body.outcome === 'proposed') text = 'Plan ready for review';
+  else if (body.outcome === 'merged') text = 'Merged on the base branch';
+  else text = `Failed\n${body.answer || 'The turn returned no outcome.'}`;
+  if (destination) text += `\n${body.outcome === 'question' ? 'Answer in Flowviant: ' : ''}${destination}`;
+  output.event(text, body.outcome === 'question' ? 'question' : 'outcome');
+  output.close();
+}
+
+/** Recovery settlements describe the retained operation, rather than a new
+ * review decision. The caller emits this once, before retrying its receipt. */
+export function reportPlanOutcome(job, body) {
+  const work = planWork(job);
+  if (body.question) return reportWorkOutcome(work, { outcome: 'question',
+    answer: [body.question.question, body.question.context].filter(Boolean).join('\n\n') });
+  if (job.recovery?.start && body.proposal) {
+    const output = createTurnOutput({ work });
+    output.event('Start diagnosis complete; continuing the approved Start', 'outcome');
+    output.close();
+    return;
+  }
+  reportWorkOutcome(work, { outcome: body.proposal ? 'proposed' : 'nothing', answer: body.error });
+}
+
+export function reportAgentOutcome(job, body) {
+  const work = agentWork(job);
+  if (job.kind === 'merge_resolve' && body.outcome === 'delivered') {
+    const output = createTurnOutput({ work });
+    output.event(body.mergeResolved === true
+      ? 'Merge repair verified; continuing the approved Merge'
+      : 'Merge repair returned; verification is still needed', 'outcome');
+    output.close();
+    return;
+  }
+  reportWorkOutcome(work, body, workDestination(work, { taskId: job.task?.id }));
+}

package/bin/lib/workAgentBriefRunner.mjs

@@ -14,7 +14,7 @@ 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 }) => {
+  return ({ agentId, turnId, workName, runtime, model }) => {
     const identity = { agentId, turnId, instance: DAEMON_INSTANCE };
     return makeAgentBrief({ runtime, model, scrub, models: knownCodexModels,
       context: async (signal) => {
@@ -46,7 +46,7 @@ export function createAgentBriefRunner({ admit, workChildren, run = runTurn, req
           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]',
+            turnArgs: { ...turnArgs, cwd, profile: 'consult', answerFromResult: true, work: { kind: 'brief', id: agentId, name: workName || 'Work brief' },
               onUsage: (u) => { usage = { ...u, runtime: turnArgs.runtime }; } } });
           return result.wedged ? '' : { out: result.out, usage };
         } finally {