flowviant 0.125.18 → 0.125.21

package/bin/lib/artifactReporter.mjs

@@ -37,10 +37,12 @@
  * with `includeNames`, so it never attributes a sibling card's files.
  */
 
+import { createArtifactCache } from './artifactCache.mjs';
 import { artifactStoredName, artifactTypeFor, scanArtifacts } from './artifacts.mjs';
+import { ARTIFACT_MULTIPART_MAX_BYTES } from './artifactPolicy.mjs';
 import { fleetHeaders } from './fleetPost.mjs';
 import {
-  imageRevisionProtection, iterationSignature, iterationChanges, deletedArtifacts, localArtifact, discardLocalArtifact, iterationInstructions,
+  declaredDiscards, imageRevisionProtection, iterationSignature, iterationChanges, deletedArtifacts, localArtifact, discardLocalArtifact, iterationInstructions,
   presentArtifacts, readSeenArtifacts, writeSeenArtifacts, seenArtifacts, serverBornAt,
 } from './artifactIteration.mjs';
 import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
@@ -74,17 +76,64 @@ export function createArtifactReporter({
    *  checkout, anything unreadable) gives a place without a record no
    *  legacy evidence at all. */
   placeBornAt = () => null,
+  projectIdentity = fleetUrl,
 }) {
   const url = fleetEndpoint('artifact', fleetUrl);
   const doFetch = fetchImpl ?? ((...a) => fetch(...a));
   const pending = new Map(); // `${owner}:${name}` -> { body, tries }
 
-  const prepare = async ({ placeDir, sessionId, agentId, before }) => {
+  const cacheFor = ({ placeDir, sessionId, agentId, cleanupGuard = null, recoveryMemo = null, preparedOnly = () => false }) => {
+    const privatePath = seenPath(placeDir, sessionId ?? agentId);
+    const project = typeof projectIdentity === 'function' ? projectIdentity() : projectIdentity;
+    if (!privatePath || !project) return null;
+    return createArtifactCache({ placeDir, path: `${privatePath}.cache`,
+      getDiscards: () => declaredDiscards(placeDir),
+      getUses: name => (cleanupGuard && cleanupGuard() !== true) || pending.has(`${sessionId ?? agentId}:${name}`) || chains.has(`${sessionId ?? agentId}:${name}`) ? ['pending-upload-or-removal'] : [],
+      scope: { projectId: project, ...(sessionId ? { sessionId } : { agentId }) },
+      fetchVersion: async ref => {
+        const key = `${ref.remote.id}:${ref.sha256}`, cached = recoveryMemo?.get(key);
+        if (cached && Date.now() >= cached.at && Date.now() - cached.at < 5_000) return cached.bytes;
+        if (preparedOnly()) throw new Error('recovery-verification-expired');
+        const query = new URLSearchParams({ ...(sessionId ? { sessionId } : { agentId }), sha256: ref.sha256 });
+        const response = await doFetch(`${url}/${encodeURIComponent(ref.remote.id)}/recover?${query}`, {
+          method: 'GET', headers: fleetHeaders({ token, json: false }), signal: AbortSignal.timeout(cleanupGuard ? 5_000 : 30_000),
+        });
+        if (!response.ok) throw new Error(`recovery-unavailable-http-${response.status}`);
+        // Bound even an incompatible server's response before buffering it.
+        const reader = response.body?.getReader();
+        if (!reader) throw new Error('recovery-unreadable');
+        const chunks = []; let size = 0;
+        try {
+          for (;;) {
+            const { done, value } = await reader.read(); if (done) break;
+            size += value.length;
+            if (size > 32 * 1024 * 1024) throw new Error('recovery-too-large');
+            chunks.push(Buffer.from(value));
+          }
+        } finally { await reader.cancel().catch(() => {}); }
+        const bytes = Buffer.concat(chunks);
+        recoveryMemo?.set(key, { bytes, at: Date.now() });
+        return bytes;
+      } });
+  };
+
+  const prepare = async ({ placeDir, sessionId, agentId, before, idle = false }) => {
     if (!before) return '';
     before.iterationSignature = iterationSignature(placeDir);
     delete before.stored;
     delete before.seen;
     before.inventoryFailed = false;
+    const cache = cacheFor({ placeDir, sessionId, agentId });
+    if (cache && !idle) {
+      // Consumer preparation is outside inventory's best-effort catch: exact
+      // recovery failure must stop this turn from consuming missing inputs.
+      const restored = await cache.restore(declaredDiscards(placeDir));
+      const snapshot = scanArtifacts(placeDir, { all: true });
+      for (const name of restored) {
+        const entry = snapshot.find(e => e.name === name);
+        if (entry) before.set(name, `${entry.size}:${entry.mtimeMs}`);
+      }
+    }
     const query = new URLSearchParams(sessionId ? { sessionId } : { agentId });
     try {
       const sentAt = Date.now();
@@ -100,6 +149,11 @@ export function createArtifactReporter({
       const result = await response.json();
       if (!Array.isArray(result.data)) { before.inventoryFailed = true; return ''; }
       before.stored = result.data.filter((a) => a && typeof a.id === 'string' && typeof a.name === 'string');
+      if (cache) for (const remote of before.stored) {
+        if (!/^[a-f0-9]{64}$/.test(remote.sha256 ?? '')) continue;
+        try { cache.record({ name: remote.name, remote }); }
+        catch { /* Unknown, missing or scrubbed local bytes are never owned. */ }
+      }
       const path = seenPath(placeDir, sessionId ?? agentId);
       before.seen = seenArtifacts(readSeenArtifacts(path), before.stored, presentArtifacts(placeDir) ?? new Set(),
         serverBornAt(placeBornAt(placeDir), response.headers?.get?.('date'), sentAt));
@@ -130,14 +184,22 @@ export function createArtifactReporter({
     }
     const form = new FormData();
     for (const [k, v] of Object.entries(body.fields)) form.set(k, v);
-    if (body.bytes) form.set('file', new Blob([body.bytes]), body.fields.name);
+    const streamed = body.bytes?.length > ARTIFACT_MULTIPART_MAX_BYTES;
+    if (body.bytes && !streamed) form.set('file', new Blob([body.bytes]), body.fields.name);
     if (body.preview) form.set('preview', new Blob([body.preview], { type: 'image/png' }), 'preview.png');
     try {
       const res = await doFetch(url, {
         method: 'POST',
-        headers: { Authorization: `Bearer ${token}`, 'User-Agent': userAgent },
+        headers: { Authorization: `Bearer ${token}`, 'User-Agent': userAgent,
+          ...(streamed ? {
+            'Content-Type': 'application/octet-stream',
+            'Content-Length': String(body.bytes.length),
+            'X-Flowviant-Artifact': JSON.stringify(body.fields),
+            'X-Content-Sha256': body.fields.sha256,
+          } : {}),
+        },
         signal: AbortSignal.timeout(30_000),
-        body: form,
+        body: streamed ? body.bytes : form,
       });
       if (res.ok) {
         const result = typeof res.json === 'function' ? await res.json().catch(() => null) : null;
@@ -186,6 +248,15 @@ export function createArtifactReporter({
       if (genOf.get(key) !== gen) return; // a newer copy decides for this key
       if (result.settled) pending.delete(key);
       else hold(key, body, tries + 1);
+      if (result.success && body.cacheInfo && result.id && body.bytes) {
+        try { cacheFor(body.cacheInfo)?.record({ name: body.fields.name,
+          remote: { id: result.id, sha256: body.fields.sha256 } }); }
+        catch (error) { log(`artifact ${body.fields.name}: local cache retained — ${error.message}`); }
+      }
+      if (result.success && body.removal) {
+        try { cacheFor(body.cacheInfo ?? { placeDir: body.placeDir, ...body.removal })?.discard(body.fields.name, body.removal.id); }
+        catch (error) { log(`artifact ${body.fields.name}: cache discard bookkeeping incomplete — ${error.message}`); }
+      }
       if (result.success && body.replacements?.length) {
         result.cleanupFailed = [];
         for (const removal of body.replacements) {
@@ -226,7 +297,7 @@ export function createArtifactReporter({
 
   /** Upload what this turn changed in `placeDir`. Resolves to the number of
    *  bodies SENT this call (delivered or held), for the tests and the log. */
-  const report = async ({ placeDir, before, sessionId, agentId, turnId, idle = false, requireStored = false, includeNames = null, requiredOutputs = null }) => {
+  const report = async ({ placeDir, before, sessionId, agentId, turnId, idle = false, requireStored = false, includeNames = null, requiredOutputs = null, referenceCapture = false }) => {
     if (!placeDir || (!sessionId && !agentId)) return 0;
     const changes = iterationChanges(placeDir, before);
     const protectedNames = imageRevisionProtection(before?.stored, before?.imageRevision);
@@ -239,6 +310,14 @@ export function createArtifactReporter({
       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.');
+    // An unreadable eviction ledger is unknown evidence, never a discard.
+    const cache = cacheFor({ placeDir, sessionId, agentId });
+    // A standing replacement is not an unconditional remove: after restart
+    // its predecessor stays cached until this report has delivery evidence.
+    const standing = iterationChanges(placeDir, null);
+    const explicitAbsences = new Set([...standing.remove, ...Object.keys(changes.replace)]);
+    try { if (before) before.evicted = cache?.absences(before?.stored ?? [], explicitAbsences) ?? new Set(); }
+    catch { if (before) before.evicted = new Set((before?.stored ?? []).map(a => a.name)); }
     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)]) {
@@ -268,7 +347,7 @@ export function createArtifactReporter({
       failures.push(`Required intermediate output ${name} is missing, unsafe or excluded from reporting; its handoff is unfinished.`);
     let n = 0;
     for (const entry of changed) {
-      const body = buildUpload(entry, { sessionId, agentId, turnId }, scrub, secretIn);
+      const body = buildUpload(entry, { sessionId, agentId, turnId, ...(referenceCapture ? { referenceCapture: true } : {}) }, scrub, secretIn);
       if (required.has(entry.name) && (!body?.bytes || body.withheld || body.fields.sha256 !== required.get(entry.name))) {
         failures.push(`Required intermediate output ${entry.name} is unreadable, withheld or changed since preparation. Restore its exact producer bytes and retry.`);
         continue;
@@ -292,6 +371,9 @@ export function createArtifactReporter({
         body.fields.renderState = measured.renderState;
         if (measured.preview) body.preview = measured.preview;
       }
+      body.cacheInfo = { placeDir, sessionId, agentId };
+      try { cache?.trackUpload(body.fields.name); }
+      catch (error) { log(`artifact ${body.fields.name}: ownership unavailable — ${error.message}`); }
       body.replacements = Object.entries(changes.replace).filter(([, to]) => to === body.fields.name).map(([name]) => {
         const key = `${sessionId ?? agentId}:${name}`;
         return { fields: { name }, removal: { ...(sessionId ? { sessionId } : { agentId }), id: stored.get(name).id, name },
@@ -377,9 +459,9 @@ export function createArtifactReporter({
    */
   const reconcile = async ({ placeDir, before, sessionId, agentId }) => {
     if (!placeDir || !before || (!sessionId && !agentId)) return 0;
-    await prepare({ placeDir, before, sessionId, agentId });
+    await prepare({ placeDir, before, sessionId, agentId, idle: true });
     return report({ placeDir, before, sessionId, agentId, idle: true });
   };
 
-  return { prepare, report, reconcile, retryPending, pendingCount: () => pending.size };
+  return { prepare, report, reconcile, cacheFor, retryPending, pendingCount: () => pending.size };
 }

package/bin/lib/artifacts.mjs

@@ -74,7 +74,8 @@
  * that cannot show an artifact must not have the CLI told it will.
  */
 
-import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readSync, rmSync } from 'node:fs';
+import { REFERENCE_CAPTURE_MANIFEST, REFERENCE_CAPTURE_FILE } from './referenceCaptureProtocol.mjs';
+import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { cutKeepingExtension } from './safeFileName.mjs';
@@ -138,7 +139,7 @@ export function ensureArtifactDir(placeDir) {
  * points both variables at it (runtimeCodex.mjs `codexDesignFence`), so the
  * shell works like a shell; nothing here is uploaded, committed or read back.
  *
- * Made EMPTY before each turn (a previous turn's scratch is nobody's), and
+ * Created before each turn without erasing unrecorded or still-required files, and
  * only as a real directory under a real `.flowviant` — the artifacts
  * directory's rule, for its reason: a fence grant on a path through a
  * committed symlink is a write grant on its target. False creates nothing
@@ -149,9 +150,8 @@ export function ensureFenceScratch(placeDir) {
   const dir = join(placeDir, FENCE_TMP_DIR);
   if (flowviantParentState(placeDir) !== 'dir' || realDirState(dir) === 'other') return false;
   try {
-    // A real directory (checked above): its contents go, never through a link.
-    if (realDirState(dir) === 'dir') rmSync(dir, { recursive: true, force: true });
-    mkdirSync(dir);
+    // Reclamation requires a versioned ownership record and released uses.
+    if (realDirState(dir) === 'none') mkdirSync(dir);
   } catch {
     return false;
   }
@@ -306,7 +306,7 @@ export const artifactStoredName = (name) => name.split('/').map(safeArtifactName
  * re-sent exactly as it was first built (scrubbed once, never re-read from a
  * disk the agent may have changed since).
  */
-export function buildArtifactUpload(entry, { sessionId, agentId, turnId }, scrub = (s) => s, secretIn = () => null) {
+export function buildArtifactUpload(entry, { sessionId, agentId, turnId, referenceCapture = false }, scrub = (s) => s, secretIn = () => null) {
   const type = artifactTypeFor(entry.name);
   const fields = {
     ...(sessionId ? { sessionId } : { agentId }),
@@ -314,6 +314,9 @@ export function buildArtifactUpload(entry, { sessionId, agentId, turnId }, scrub
     name: artifactStoredName(entry.name),
     bytes: String(entry.size),
   };
+  // Reserved evidence names are writable only by the measured browser
+  // consumer. Model-authored JSON cannot become a page-access measurement.
+  if (REFERENCE_CAPTURE_FILE.test(entry.name) && !referenceCapture) return { withheld: 'measured-reference-capture-only', fields };
   if (!type) return { fields, bytes: null }; // reported by name only
   const maxBytes = artifactMaxBytesFor(entry.name);
   if (entry.size > maxBytes) return { fields: { ...fields, tooLarge: '1' }, bytes: null };
@@ -329,7 +332,10 @@ export function buildArtifactUpload(entry, { sessionId, agentId, turnId }, scrub
     const secret = secretIn(bytes);
     if (secret) return { withheld: secret, fields };
   } else {
+    const original = bytes;
     bytes = Buffer.from(String(scrub(bytes.toString('utf8'))), 'utf8');
+    if (REFERENCE_CAPTURE_MANIFEST.test(entry.name) && !bytes.equals(original))
+      return { withheld: 'reference-capture-redaction', fields };
     // A redaction marker can be longer than the value it replaced.
     if (bytes.byteLength > maxBytes) {
       return { fields: { ...fields, bytes: String(bytes.byteLength), tooLarge: '1' }, bytes: null };

package/bin/lib/claudeStream.mjs

@@ -198,6 +198,7 @@ export function handleStreamLine(line, options) {
     for (const b of ev.message.content) {
       if (b.type === 'tool_result') onToolEvent?.(null, {}, {
         id: b.tool_use_id, result: true, isError: b.is_error === true,
+        toolSuccess: 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') : '',
@@ -232,6 +233,12 @@ export function handleStreamLine(line, options) {
     // alias, and this is the CLI naming what it chose. See turnModel.mjs.
     const resolved = turnModelOf(ev.model);
     if (resolved) onModel?.(resolved);
+    if (Array.isArray(ev.tools)) for (const tool of ['WebSearch', 'WebFetch']) {
+      onToolEvent?.('WebsiteAccess', { method: 'capability', tool }, {
+        id: `website-capability:${tool}`, result: true,
+        website: { access: 'unknown', availability: ev.tools.includes(tool) ? 'advertised' : 'unknown' },
+      });
+    }
     if (Array.isArray(ev.skills) || typeof ev.session_id === 'string' || Array.isArray(ev.mcp_servers)) {
       onInit?.({
         skills: Array.isArray(ev.skills) ? ev.skills.map(String) : undefined,

package/bin/lib/codexFencedMount.mjs

@@ -109,7 +109,7 @@ const table = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
  * config.toml could not be read), and
  * `unmounted` `[{ name, reason, source: 'project' | 'machine', partial? }]`.
  */
-export function codexFencedMount(usable, expand, machineEnv, turnServers = {}) {
+export function codexFencedMount(usable, expand, machineEnv, turnServers = {}, { includeMachine = true } = {}) {
   const args = [];
   const childEnv = {};
   const mounted = [];
@@ -192,7 +192,7 @@ export function codexFencedMount(usable, expand, machineEnv, turnServers = {}) {
   }
 
   const projectNames = new Set([...usable.map((t) => t.name), ...ownNames]);
-  const personal = machineCodexServers(machineEnv);
+  const personal = includeMachine ? machineCodexServers(machineEnv) : [];
   for (const [name, server] of personal ?? []) {
     if (projectNames.has(name) || server.enabled === false) continue;
     if (typeof server.command !== 'string' && typeof server.url !== 'string') continue;

package/bin/lib/fleet.mjs

@@ -278,6 +278,7 @@ export async function runFleetDaemon({ afterLock = null } = {}) {
     retireWorkSessions,
     reportWorktrees,
     reconcileIdleArtifacts,
+    reconcileLocalCleanup,
     shutdownWork,
     settleAgentTurns,
     workBusy,
@@ -291,6 +292,7 @@ export async function runFleetDaemon({ afterLock = null } = {}) {
     getBaseRef,
     getMcpUrl: () => mcpUrl,
     getLeaseTtl: () => leaseTtlSeconds,
+    getCleanupPermission: () => holderState === 'mine' && !standingDown() && !readMaintenance(),
     /**
      * The cartographer is a CLI turn too, and it is the one this manager cannot
      * see — it lives in the wiki runner (wikiRunner.mjs), not in
@@ -649,6 +651,13 @@ export async function runFleetDaemon({ afterLock = null } = {}) {
     // once per process, beside no turn (workArtifactReconcile.mjs). After the
     // turn intake above, so a card about to run in a place is not raced.
     void reconcileIdleArtifacts(roster.activeWorkSessions)?.catch(() => {});
+    // First authoritative serving roster triggers startup recovery; later
+    // idle beats are bounded internally. Refresh evidence on every roster so
+    // an in-flight remote check cannot outlive ownership or a peer lease.
+    void reconcileLocalCleanup({ activeIds: roster.activeWorkSessions,
+      heldElsewhere: roster.sessionsHeldElsewhere, serving: holderState === 'mine',
+      draining: standingDown() || Boolean(readMaintenance()),
+    });
     // Terminal-session presence, throttled + dedup'd inside; never awaited —
     // the daemon's own worktrees are carved out (a session the daemon spawned
     // is already a tab, not something to offer adopting).

package/bin/lib/intermediateArtifacts.mjs

@@ -33,7 +33,7 @@ function readRegular(path, max = ARTIFACT_BINARY_MODEL_MAX_BYTES) {
   try {
     const stat = fstatSync(fd);
     if (!stat.isFile()) throw new Error('Intermediate artifact is not a regular file.');
-    if (stat.size > max) throw new Error(`Intermediate artifact is ${stat.size} bytes; the per-file limit is ${max} bytes.`);
+    if (stat.size > max) throw new Error(`Intermediate artifact is ${stat.size} bytes; the per-file limit is ${max} bytes. Preserve these exact producer bytes and retry after a compatible update, or revise this producer explicitly.`);
     const bytes = Buffer.alloc(stat.size);
     let offset = 0;
     while (offset < bytes.length) {
@@ -116,7 +116,7 @@ export function createIntermediateArtifacts({ wt, agentId, path, exportPage = ex
       try {
         if (!safeName(ref.name) || !/^[a-f0-9]{64}$/.test(ref.sha256) || ref.path !== copyPath(ref.sha256, ref.name))
           throw new Error('Invalid intermediate artifact version identity.');
-        if (!historical && state.pending?.taskId && state.pending.taskId === ref.taskId && state.pending.sources.some(source =>
+        if (!historical && state.pending && (state.pending.recovery === true || state.pending.taskId === ref.taskId) && state.pending.sources.some(source =>
           source.name === ref.name || source.name === ref.model?.page)) throw new Error('Producer handoff remains unfinished');
         let bytes;
         try { bytes = readIntermediateFile(wt, ref.path); }
@@ -145,15 +145,21 @@ export function createIntermediateArtifacts({ wt, agentId, path, exportPage = ex
     const state = load(), taskId = taskOf(job);
     const identity = { agentId, taskId, turnId, taskKind };
     const standing = scanArtifacts(wt, { all: true });
-    const changed = changedArtifacts(before, standing);
+    let changed = changedArtifacts(before, standing);
     // Failed export/storage retries are tied to a card and exact source hash.
     // A changed page is a new version; it never reuses a previous GLB receipt.
     // A source the agent's iteration declaration discards or replaces is the
     // explicit revision and leaves the retry set.
-    const pending = state.pending?.taskId === taskId && taskId ? state.pending : null;
+    const pending = state.pending?.taskId === taskId && (taskId || (state.pending.recovery === true && job.kind === 'human')) ? state.pending : null;
+    if (state.pending?.recovery && !pending)
+      throw new Error('An exact producer recovery is pending. Retry that producer before starting different work.');
+    if (pending?.recovery) {
+      identity.recoveredFromTurnId = pending.recoverySourceTurnId ?? pending.turnId;
+      changed = changed.filter(e => pending.sources.some(s => s.name === e.name));
+    }
     const discarded = pending ? declaredDiscards(wt) : new Set();
     if (pending) for (const ref of pending.sources) {
-      if (changed.some(e => e.name === ref.name) || discarded.has(artifactStoredName(ref.name))) continue;
+      if (!pending.recovery && (changed.some(e => e.name === ref.name) || discarded.has(artifactStoredName(ref.name)))) continue;
       const entry = standing.find(e => e.name === ref.name);
       let bytes;
       try { bytes = readIntermediateFile(wt, `.flowviant/artifacts/${ref.name}`, artifactMaxBytesFor(ref.name)); }
@@ -161,7 +167,7 @@ export function createIntermediateArtifacts({ wt, agentId, path, exportPage = ex
       if (hash(bytes) !== ref.sha256)
         throw new Error(`Required intermediate output ${ref.name} is missing or changed since the failed handoff. Restore it or revise the producer explicitly, then retry.`);
       if (!entry) throw new Error(`Required intermediate output ${ref.name} is outside the safe artifact walk (non-hidden paths with at most ${ARTIFACT_MAX_DEPTH} directories). Move it to a supported artifact path and retry this producer.`);
-      changed.push(entry);
+      if (!changed.some(e => e.name === entry.name)) changed.push(entry);
     }
     if (taskKind === 'model' && !changed.some(e => /\.html?$/i.test(e.name)) && (job.kind !== 'task' || job.redo === true) && taskId) {
       for (const ref of state.files.filter(f => f.taskId === taskId && f.taskKind === 'model' && /\.html?$/i.test(f.name))) {
@@ -171,7 +177,7 @@ export function createIntermediateArtifacts({ wt, agentId, path, exportPage = ex
     }
     const pages = taskKind === 'model' ? changed.filter(e => /\.html?$/i.test(e.name)) : [];
     const outputs = changed.filter(e => artifactTypeFor(e.name));
-    state.pending = { taskId, turnId, sources: outputs.map(e => ({ name: e.name, sha256: hash(readIntermediateFile(wt, `.flowviant/artifacts/${e.name}`, artifactMaxBytesFor(e.name))) })), exports: pending?.exports ?? [] };
+    state.pending = { taskId, turnId, ...(pending?.recovery ? { recovery: true, recoverySourceTurnId: identity.recoveredFromTurnId } : {}), sources: outputs.map(e => ({ name: e.name, sha256: hash(readIntermediateFile(wt, `.flowviant/artifacts/${e.name}`, artifactMaxBytesFor(e.name))) })), exports: pending?.exports ?? [] };
     save(state);
     const exports = [];
     for (const page of pages) {
@@ -226,7 +232,33 @@ export function createIntermediateArtifacts({ wt, agentId, path, exportPage = ex
       save({ ...state, files: [...byName.values()], pending: null });
     } };
   };
-  return { inputs, prepare };
+  /** Offline recovery of an interrupted producer with no saved pending set.
+   * The operator supplies the original log/export binding, never a new model
+   * or a same-name Library lookup. This publishes no consumer receipt. */
+  const restorePending = ({ taskId, turnId, sources, exports }) => {
+    const id = /^[A-Za-z0-9_-]{1,80}$/;
+    if (!(taskId === null || id.test(taskId ?? '')) || !id.test(turnId ?? '') ||
+        !Array.isArray(sources) || !sources.length || sources.length > ARTIFACT_MAX_PER_AGENT ||
+        !Array.isArray(exports) || !exports.length ||
+        new Set(sources.map(s => s.name)).size !== sources.length)
+      throw new Error('Recovery needs the exact producer task, turn, source hashes and page-export bindings.');
+    const state = load();
+    if (state.pending && (state.pending.taskId !== taskId || state.pending.turnId !== turnId))
+      throw new Error('Another producer handoff is pending. Preserve its receipt before recovery.');
+    for (const ref of sources) {
+      if (!safeName(ref.name) || !artifactTypeFor(ref.name) || !/^[a-f0-9]{64}$/.test(ref.sha256 ?? '') ||
+          hash(readIntermediateFile(wt, `.flowviant/artifacts/${ref.name}`, artifactMaxBytesFor(ref.name))) !== ref.sha256)
+        throw new Error(`Recovery source ${ref.name} does not match its original producer hash. Restore the exact bytes before retrying.`);
+    }
+    if (!exports.every(ref => ref.name === ref.page?.replace(/\.html?$/i, '.glb') &&
+        /\.html?$/i.test(ref.page) && sources.some(s => s.name === ref.page && s.sha256 === ref.pageSha256) &&
+        sources.some(s => s.name === ref.name && s.sha256 === ref.sha256)) || !measuredModelExports(wt, exports))
+      throw new Error('Recovery page/export binding is missing, changed or unusable. Restore the original producer export evidence.');
+    save({ ...state, pending: { taskId, turnId, recovery: true, recoverySourceTurnId: turnId,
+      sources: sources.map(({ name, sha256 }) => ({ name, sha256 })),
+      exports: exports.map(({ page, pageSha256, name, sha256 }) => ({ page, pageSha256, name, sha256 })) } });
+  };
+  return { inputs, prepare, restorePending };
 }
 
 export function intermediateArtifactContext(files = []) {

package/bin/lib/knowledgeLibrary.mjs

@@ -41,6 +41,7 @@
  */
 
 import { safeFileName } from './safeFileName.mjs';
+import { ARTIFACT_BINARY_MODEL_MAX_BYTES } from './artifactPolicy.mjs';
 
 /** Relative to the checkout, under `.flowviant/` beside the turn uploads and
  *  the artifacts — see `FLOWVIANT_OWN_PATHS` for why that is NOT one exclude
@@ -140,7 +141,7 @@ export const INSTRUCTIONS_FILE = 'INSTRUCTIONS.md';
 export const KNOWLEDGE_FILE_MAX_BYTES = 10 * 1024 * 1024;
 export const KNOWLEDGE_BINARY_MODEL_MAX_BYTES = 20 * 1024 * 1024;
 export const knowledgeMaxFor = (name, base) => /\.(glb|bin)$/i.test(name)
-  ? Math.max(base, KNOWLEDGE_BINARY_MODEL_MAX_BYTES) : base;
+  ? Math.max(base, /^(models|designs)\//.test(name) ? ARTIFACT_BINARY_MODEL_MAX_BYTES : KNOWLEDGE_BINARY_MODEL_MAX_BYTES) : base;
 /** The manifest is capped at the server (25 files); a manifest longer than
  *  this is not one the product produced, and is cut rather than trusted. */
 export const MAX_FILES = 64;

package/bin/lib/localCleanupReport.mjs

@@ -0,0 +1,34 @@
+/** Local diagnostics only: consume measured outcomes, never estimate disk use. */
+import { randomUUID } from 'node:crypto';
+import { retainTurnRecord } from './daemonLogging.mjs';
+import { encodeDetailRecord, decodeDetailRecord } from './daemonJournal.mjs';
+import { formatTurnRecord } from './turnRecord.mjs';
+
+export function reportLocalCleanup(entry, { retain = retainTurnRecord,
+  write = text => process.stderr.write(text) } = {}) {
+  if (!entry || entry.reason === 'already-evicted') return true;
+  const id = entry.id || randomUUID();
+  const bytes = entry.status === 'reclaimed' && Number.isFinite(entry.bytes) && entry.bytes >= 0 ? entry.bytes : null;
+  const text = JSON.stringify({ operation: entry.kind === 'artifact' ? 'local-cache-eviction' : 'managed-local-cleanup',
+    attemptId: id, status: entry.status, kind: entry.kind,
+    name: entry.name, path: entry.path, projectId: entry.projectId,
+    place: entry.place, placeDir: entry.placeDir, agentId: entry.agentId,
+    sessionId: entry.sessionId, localVersion: entry.localVersion,
+    reclaimedFiles: entry.status === 'reclaimed' ? 1 : 0,
+    reclaimedBytes: bytes, reason: entry.reason, error: entry.error,
+    incomplete: entry.incomplete === true,
+    retryAt: entry.status === 'failed' || entry.incomplete || entry.status === 'retained' ? entry.nextAt : undefined,
+    tries: entry.tries, resumedAttempt: entry.resumedAttempt,
+    previousCompletion: entry.previousCompletion,
+    cloudCopies: 'unchanged', repositoryFiles: 'unchanged' });
+  // Use the journal's own scrub/clip policy even when retention fails and the
+  // complete diagnostic must be shown live. No raw paths/errors reach output.
+  const record = decodeDetailRecord(encodeDetailRecord({ kind: 'cleanup',
+    name: 'Local cleanup', workId: entry.agentId || entry.sessionId || entry.place || '',
+    turnId: entry.turnId || `cleanup:${id}`, source: `cleanup:${id}`,
+    observedAt: entry.at ?? Date.now(), text }));
+  const retained = retain(record);
+  if (retained !== true || entry.status === 'failed' || entry.incomplete)
+    write(formatTurnRecord(record, { color: false }));
+  return retained === true;
+}

package/bin/lib/localCleanupState.mjs

@@ -0,0 +1,68 @@
+/** Private operational attempts, not a diagnostic log. Atomic and bounded;
+ * losing/corrupting state never grants permission to delete. */
+import { constants, openSync, closeSync, fstatSync, readFileSync, writeFileSync, fsyncSync, renameSync, rmSync, lstatSync, realpathSync, linkSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { processAlive, processStartTime, bootMark, sameBoot } from './procRegistry.mjs';
+
+export function cleanupState(path, identity) {
+  if (realpathSync(dirname(path)) !== resolve(dirname(path))) throw new Error('cleanup-state-parent-unsafe');
+  const read = file => {
+    const fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      const st = fstatSync(fd);
+      if (!st.isFile() || st.size > 2 * 1024 * 1024) throw new Error('cleanup-state-unreadable');
+      return JSON.parse(readFileSync(fd, 'utf8'));
+    } finally { closeSync(fd); }
+  };
+  const load = () => {
+    let value;
+    try { value = read(path); }
+    catch (e) { if (e.code === 'ENOENT') return { version: 1, identity, cursor: 0, attempts: {}, results: [] }; throw e; }
+    if (value.version !== 1 || value.identity !== identity || !Number.isSafeInteger(value.cursor) || value.cursor < 0 ||
+        !value.attempts || typeof value.attempts !== 'object' || Array.isArray(value.attempts) || Object.keys(value.attempts).length > 2000 ||
+        !Array.isArray(value.results) || value.results.length > 128 || Object.values(value.attempts).some(a =>
+          !Number.isFinite(a.nextAt) || !Number.isSafeInteger(a.tries) || a.tries < 0)) throw new Error('cleanup-state-unreadable');
+    return value;
+  };
+  const save = value => {
+    const tmp = `${path}.${randomUUID()}.tmp`, bytes = JSON.stringify(value);
+    if (Buffer.byteLength(bytes) > 2 * 1024 * 1024) throw new Error('cleanup-state-budget-exhausted');
+    try {
+      const fd = openSync(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+      try { writeFileSync(fd, bytes); fsyncSync(fd); } finally { closeSync(fd); }
+      renameSync(tmp, path);
+      const parent = openSync(dirname(path), constants.O_RDONLY | constants.O_NOFOLLOW);
+      try { fsyncSync(parent); } finally { closeSync(parent); }
+    } finally { rmSync(tmp, { force: true }); }
+  };
+  /** No age-only lock stealing: a live or unreadable holder keeps its claim. */
+  const claim = () => {
+    const lock = `${path}.lock`, token = randomUUID();
+    for (let i = 0; i < 2; i++) {
+      try {
+        const tmp = `${lock}.${token}.tmp`;
+        try {
+          const fd = openSync(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+          try { writeFileSync(fd, JSON.stringify({ identity, token, pid: process.pid, start: processStartTime(process.pid), boot: bootMark() })); fsyncSync(fd); }
+          finally { closeSync(fd); }
+          linkSync(tmp, lock); // publish only complete ownership evidence
+        } finally { rmSync(tmp, { force: true }); }
+        return () => { try { if (read(lock).token === token) rmSync(lock); } catch { /* retain an unknown replacement */ } };
+      } catch (error) {
+        if (error.code !== 'EEXIST') return null;
+        try {
+          const stat = lstatSync(lock), holder = read(lock);
+          if (holder.identity !== identity || !Number.isInteger(holder.pid) || holder.pid <= 1) return null;
+          const alive = processAlive(holder.pid), start = processStartTime(holder.pid);
+          if (alive && (!holder.boot || sameBoot(holder.boot)) && (!holder.start || !start || start === holder.start)) return null;
+          const current = lstatSync(lock);
+          if (current.ino !== stat.ino || current.mtimeMs !== stat.mtimeMs) return null;
+          rmSync(lock);
+        } catch { return null; }
+      }
+    }
+    return null;
+  };
+  return { load, save, claim };
+}

package/bin/lib/logReplay.mjs

@@ -29,10 +29,16 @@ function openCursor(path) {
 
 export function createLogReader(path, { turnId = null } = {}) {
   let current = null, previousSeen = null, initialized = false, closed = false;
+  const cleanupIds = new Set();
   const line = (raw, batch) => {
     const row = decodeDetailRecord(raw);
     if (row === false) { batch.lines.push('[detail gap: an incomplete or unreadable retained record was skipped]'); return; }
     if (row) {
+      if (row.kind === 'cleanup' && row.source.startsWith('cleanup:')) {
+        if (cleanupIds.has(row.source)) return;
+        if (cleanupIds.size >= 8192) cleanupIds.delete(cleanupIds.values().next().value);
+        cleanupIds.add(row.source);
+      }
       if (turnId !== null && !matchesTurn(row.turnId, turnId)) return;
       batch.matched++;
       for (const text of formatTurnRecord(row, { color: false }).slice(0, -1).split('\n')) batch.lines.push(text);