@inflexa-ai/harness 0.23.0 → 0.25.0

package/dist/input-scan/scan.js

@@ -0,0 +1,182 @@
+/**
+ * The input scan — one deterministic pass over a staged input tree.
+ *
+ * Runs in the harness process over the workspace read seam, which is
+ * sandbox-independent: the walk touches names and metadata, and format detection
+ * compares a bounded byte prefix against a table. Neither is a decode, so neither
+ * needs a container. Only the per-shape header readout (`enrich.ts`) runs a decoder,
+ * and it runs in the sandbox.
+ *
+ * The scan is the SOLE enumeration pass. Before it, the profiler agent discovered
+ * structure by issuing one command per input file, so its cost scaled with file
+ * count and its step budget did not.
+ */
+import { unwrapOrThrow } from "../lib/result.js";
+import { MAGIC_PREFIX_BYTES, detectFormat, extensionChain } from "./formats.js";
+import { observeShapes } from "./shapes.js";
+/**
+ * Files walked before the scan reports truncation instead of completing.
+ *
+ * Header decode is O(shapes), but the walk and its per-file prefix read are O(files),
+ * and that arm needs a stated ceiling rather than an implicit one. 100k files is ~30s
+ * of stat-and-prefix work against a 20-minute profile deadline, and two orders of
+ * magnitude above the largest tree the platform has seen (3513). Past it the scan
+ * stops and SAYS it stopped: a silently sampled manifest would describe a fraction of
+ * the tree while reading as a description of all of it, which is the failure mode this
+ * capability exists to remove.
+ */
+export const MAX_SCANNED_FILES = 100_000;
+/** Walk the tree breadth-first, reading a bounded prefix of each file for format detection. */
+async function walk(args) {
+    const { session, fs, root, signal } = args;
+    const limit = args.limit ?? MAX_SCANNED_FILES;
+    const files = [];
+    const queue = [root];
+    let truncated = false;
+    while (queue.length > 0) {
+        signal?.throwIfAborted();
+        const dir = queue.shift();
+        const listing = unwrapOrThrow(await fs.list({ session, path: dir }));
+        // A directory that vanished mid-walk, or one the seam refuses, is not a scan
+        // failure — the tree is being described, not validated.
+        if (listing.kind !== "ok")
+            continue;
+        for (const entry of listing.entries) {
+            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+            if (entry.type === "directory") {
+                queue.push(path);
+                continue;
+            }
+            if (files.length >= limit) {
+                truncated = true;
+                return { files, truncated };
+            }
+            const extensions = extensionChain(entry.name);
+            const read = unwrapOrThrow(await fs.readBytes({ session, path, length: MAGIC_PREFIX_BYTES }));
+            const prefix = read.kind === "ok" ? read.bytes : null;
+            const { format, wrapper } = detectFormat({ path, extensions, prefix });
+            files.push({
+                path,
+                size: entry.size ?? 0,
+                extensions,
+                format,
+                ...(wrapper ? { wrapper } : {}),
+            });
+        }
+    }
+    return { files, truncated };
+}
+function formatCensus(files) {
+    const counts = new Map();
+    for (const file of files)
+        counts.set(file.format, (counts.get(file.format) ?? 0) + 1);
+    return [...counts.entries()].map(([format, count]) => ({ format, count })).sort((a, b) => b.count - a.count || a.format.localeCompare(b.format, "en"));
+}
+/** Assemble a manifest from an already-walked file set. Pure — the seam of the unit tests. */
+export function buildManifest(root, files, truncated, limit = MAX_SCANNED_FILES) {
+    const observed = observeShapes(files);
+    const manifest = {
+        root,
+        fileCount: files.length,
+        totalBytes: files.reduce((sum, f) => sum + f.size, 0),
+        truncated,
+        ...(truncated ? { scanLimit: limit } : {}),
+        shapesTruncated: observed.shapesTruncated,
+        formats: formatCensus(files),
+        shapes: observed.shapes,
+        valueOverlaps: observed.valueOverlaps,
+        unstructured: observed.unstructured,
+    };
+    return { files, manifest, positionValues: observed.positionValues };
+}
+/** Walk a staged input tree and observe its shapes. No model, no container. */
+export async function scanInputTree(args) {
+    const limit = args.limit ?? MAX_SCANNED_FILES;
+    const { files, truncated } = await walk(args);
+    return buildManifest(args.root, files, truncated, limit);
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}
+/**
+ * Render a manifest for a briefing or a tool result.
+ *
+ * Bounded by construction — every list it draws from is already capped — so a tree of
+ * three thousand files costs the same context as a tree of thirty. The wording states
+ * observations only: it never calls a shape a kind, and it says outright that the
+ * grouping decision is the reader's.
+ */
+export function renderInputScanManifest(manifest) {
+    const lines = [];
+    lines.push(`Input scan of ${manifest.root} — ${manifest.fileCount} files, ${formatBytes(manifest.totalBytes)}.`);
+    if (manifest.truncated) {
+        lines.push(`INCOMPLETE: the walk stopped at its ${manifest.scanLimit ?? MAX_SCANNED_FILES}-file ceiling, so this describes part of the tree.`);
+    }
+    lines.push(`Formats: ${manifest.formats.map((f) => `${f.format} (${f.count})`).join(", ") || "none"}`);
+    lines.push("");
+    lines.push("These are OBSERVATIONS of filename structure, not a grouping of the dataset.");
+    lines.push("A shape is a set of files whose names differ only at the marked positions; deciding");
+    lines.push("what is one kind of data, and what the varying positions mean, is your judgement.");
+    if (manifest.shapes.length > 0) {
+        lines.push("");
+        lines.push(`Shapes (${manifest.shapes.length}${manifest.shapesTruncated ? ", capped — the remainder is in the aggregate below" : ""}):`);
+        for (const shape of manifest.shapes) {
+            const location = shape.directory ? `${shape.directory}/` : "";
+            const wrapper = shape.wrapper ? `, ${shape.wrapper}-compressed` : "";
+            lines.push(`- ${shape.id}: ${shape.fileCount} files at ${location}${shape.pattern} (${shape.format}${wrapper}, ${formatBytes(shape.totalBytes)})`);
+            for (const position of shape.variablePositions) {
+                const prefix = position.prefix ? ` after "${position.prefix}"` : "";
+                const shown = position.sampleValues.join(", ");
+                const more = position.distinctValues > position.sampleValues.length ? ", …" : "";
+                lines.push(`  - position <${position.index}>${prefix}: ${position.distinctValues} distinct values — ${shown}${more}`);
+            }
+            for (const pair of shape.cooccurrence) {
+                const crossing = pair.observedPairs === pair.possiblePairs ? "fully crossed" : `partially crossed (${pair.possiblePairs} possible)`;
+                lines.push(`  - positions <${pair.positions[0]}>×<${pair.positions[1]}>: ${pair.observedPairs} observed combinations, ${crossing}`);
+            }
+            if (shape.header) {
+                const fields = Object.entries(shape.header.fields)
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join(", ");
+                lines.push(`  - header (${shape.header.path}): ${fields || shape.header.unavailable || "no fields read"}`);
+            }
+            else {
+                lines.push(`  - example: ${shape.examplePaths[0] ?? "—"}`);
+            }
+        }
+    }
+    if (manifest.valueOverlaps.length > 0) {
+        lines.push("");
+        lines.push("Value overlap between shapes (evidence, NOT an assertion that they share an axis):");
+        for (const overlap of manifest.valueOverlaps) {
+            const gaps = [];
+            if (overlap.onlyInFirst > 0)
+                gaps.push(`${overlap.onlyInFirst} only in ${overlap.shapes[0]} (${overlap.onlyInFirstSample.join(", ")})`);
+            if (overlap.onlyInSecond > 0)
+                gaps.push(`${overlap.onlyInSecond} only in ${overlap.shapes[1]} (${overlap.onlyInSecondSample.join(", ")})`);
+            const gapText = gaps.length > 0 ? `; ${gaps.join("; ")}` : "; no gaps";
+            lines.push(`- ${overlap.shapes[0]}<${overlap.positions[0]}> vs ${overlap.shapes[1]}<${overlap.positions[1]}>: ` +
+                `${overlap.sharedValues} shared values${gapText}`);
+        }
+    }
+    if (manifest.unstructured.count > 0) {
+        lines.push("");
+        lines.push(`Files sharing no name structure with any other (${manifest.unstructured.count}, ${formatBytes(manifest.unstructured.totalBytes)}):`);
+        for (const entry of manifest.unstructured.sample) {
+            lines.push(`- ${entry.path} (${entry.format}, ${formatBytes(entry.size)})`);
+        }
+        if (manifest.unstructured.count > manifest.unstructured.sample.length) {
+            lines.push(`- … ${manifest.unstructured.count - manifest.unstructured.sample.length} more not listed`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/input-scan/shapes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shape observation — pure functions over filenames and sizes, no I/O.
+ *
+ * A shape is a mechanical fact: these filenames differ only here. Establishing it
+ * needs nothing but names, sizes, and the format already detected, which is why
+ * shapes are observed BEFORE any decode and why header enrichment costs O(shapes)
+ * rather than O(files).
+ *
+ * Grouping proceeds in two passes. The first masks digit runs, so `PATIENT_001` and
+ * `PATIENT_002` land together while `tumor_001` and `normal_001` do not. The second
+ * merges groups that differ in exactly one alphabetic position, which is what makes
+ * `tumor`/`normal` one shape with a categorical position rather than two shapes an
+ * agent has to notice are related. A file whose structure matches no other survives
+ * both passes alone and is reported in the aggregate, never as a shape of one.
+ */
+import type { FileShape, ScannedFile, ShapeValueOverlap, UnstructuredFiles } from "./types.js";
+/** Shapes reported before the tail is folded into the aggregate. */
+export declare const MAX_SHAPES = 30;
+/** Values sampled per variable position. The sample is the agent's decision material. */
+export declare const MAX_SAMPLE_VALUES = 20;
+type AtomKind = "alpha" | "digit" | "delim";
+interface Atom {
+    readonly kind: AtomKind;
+    readonly value: string;
+}
+/**
+ * Split a filename stem into runs of letters, runs of digits, and the delimiters
+ * between them. Splitting INSIDE a token is what makes `PT001_D0_rep1` three
+ * positions rather than three opaque tokens — the nested design is only visible
+ * once `PT` and `001` are separate.
+ */
+export declare function tokenizeStem(stem: string): readonly Atom[];
+/** The name stem — the basename with its extension chain removed. */
+export declare function nameStem(fileName: string): string;
+export interface ObservedShapes {
+    readonly shapes: readonly FileShape[];
+    readonly unstructured: UnstructuredFiles;
+    readonly valueOverlaps: readonly ShapeValueOverlap[];
+    /** Complete per-position value sets, keyed by shape id — the manifest carries only a sample. */
+    readonly positionValues: ReadonlyMap<string, readonly (readonly string[])[]>;
+    /** True when the shape list was capped and the remainder folded into the aggregate. */
+    readonly shapesTruncated: boolean;
+}
+/** Observe the shapes of a scanned file set. Pure — no I/O, no container, no model. */
+export declare function observeShapes(files: readonly ScannedFile[]): ObservedShapes;
+export {};

package/dist/input-scan/types.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Input-scan vocabulary.
+ *
+ * The scan reports what is OBSERVABLE about a staged input tree; it never decides
+ * how the tree is grouped (see the input-scan-manifest spec). That separation is
+ * carried by the vocabulary itself: a shape is "these filenames differ only here",
+ * a kind is "these files are the same sort of thing", and only the profiler agent
+ * can establish the second. Nothing here is named `kinds` or `axes`, and no type
+ * here is assignable to the profiler's output — a manifest an agent could copy
+ * into its submission would make its central judgement invisible.
+ */
+/** One file the walk found. `path` is relative to the analysis root. */
+export interface ScannedFile {
+    readonly path: string;
+    readonly size: number;
+    /** Trailing extension components, outermost last: `sample.vcf.gz` → `["vcf", "gz"]`. */
+    readonly extensions: readonly string[];
+    /** Format identified from magic bytes, falling back to the extension chain, else `"unknown"`. */
+    readonly format: string;
+    /** Compression wrapper reported ALONGSIDE the inner format, never in place of it. */
+    readonly wrapper?: string;
+}
+/**
+ * A filename position whose token differs across a shape's members.
+ *
+ * `sampleValues` is normative, not decoration: a count alone cannot distinguish an
+ * identifier (`0001`…`1171`) from a categorical label (`tumor`/`normal`) from a shard
+ * index (`chr1`…`chr22`), and those readings imply entirely different kinds.
+ */
+export interface VariablePosition {
+    /** Token index within the shape's name pattern — the `<n>` placeholder it fills. */
+    readonly index: number;
+    /** Literal text immediately preceding the token, when any (`PT` in `PT001`). */
+    readonly prefix?: string;
+    readonly distinctValues: number;
+    /** Bounded sample of the values observed at this position. */
+    readonly sampleValues: readonly string[];
+}
+/**
+ * How two variable positions vary together. A fully-crossed pair is a nested design
+ * (every subject × every timepoint); a partially-crossed one is not, and the
+ * difference is design evidence a flat file count destroys.
+ */
+export interface PositionCooccurrence {
+    readonly positions: readonly [number, number];
+    /** Distinct value pairs observed. */
+    readonly observedPairs: number;
+    /** Pairs the two value sets could form. `observedPairs === possiblePairs` is a full crossing. */
+    readonly possiblePairs: number;
+}
+/** Header fields read from a bounded prefix of one member of a shape. */
+export interface HeaderReadout {
+    /** The member the readout came from. */
+    readonly path: string;
+    /** Decoder-reported fields, flat and bounded (`delimiter`, `columns`, `sampleCount`, …). */
+    readonly fields: Readonly<Record<string, string | number | boolean>>;
+    /** Why no readout is present, when the decode did not produce one. */
+    readonly unavailable?: string;
+}
+/**
+ * A set of files that are mechanically indistinguishable by name structure, format,
+ * and location. A shape is an observation, never a grouping of the dataset: the
+ * agent may split one shape into several kinds, cover several shapes with one kind,
+ * or ignore the shape entirely.
+ */
+export interface FileShape {
+    /** Stable within one manifest (`shape-1`, `shape-2`, …) so overlaps can name shapes. */
+    readonly id: string;
+    /** Directory the members share, relative to the analysis root. */
+    readonly directory: string;
+    /** Name pattern with each variable position rendered as `<n>`. */
+    readonly pattern: string;
+    readonly format: string;
+    readonly wrapper?: string;
+    readonly extensions: readonly string[];
+    readonly fileCount: number;
+    readonly totalBytes: number;
+    readonly variablePositions: readonly VariablePosition[];
+    readonly cooccurrence: readonly PositionCooccurrence[];
+    /** Bounded sample of member paths. */
+    readonly examplePaths: readonly string[];
+    /** Present once sandbox enrichment has run for this shape. */
+    readonly header?: HeaderReadout;
+}
+/**
+ * Value-set overlap between two shapes' variable positions, reported WITH its gaps.
+ *
+ * Correspondence across shapes is heuristic — it depends on stripping shape-specific
+ * text before comparing, and near-miss namings defeat it. Reported as evidence it is
+ * useful; asserted as a shared axis it is a guess a consumer cannot tell was guessed.
+ */
+export interface ShapeValueOverlap {
+    readonly shapes: readonly [string, string];
+    readonly positions: readonly [number, number];
+    readonly sharedValues: number;
+    /** Values present in the first shape and absent from the second. */
+    readonly onlyInFirst: number;
+    readonly onlyInSecond: number;
+    /** Bounded samples of the two gaps, so a near-complete correspondence names its misses. */
+    readonly onlyInFirstSample: readonly string[];
+    readonly onlyInSecondSample: readonly string[];
+}
+/** One member of the no-shared-structure aggregate. */
+export interface UnstructuredEntry {
+    readonly path: string;
+    readonly size: number;
+    readonly format: string;
+}
+/**
+ * Files whose name structure matches no other file, in aggregate.
+ *
+ * Never one shape per file: a tree of arbitrarily named files would otherwise produce
+ * a shape count proportional to the file count, which is the unbounded output this
+ * capability exists to prevent. Whether these are notable singletons worth prose or
+ * an unclassified remainder is the agent's determination.
+ */
+export interface UnstructuredFiles {
+    readonly count: number;
+    readonly totalBytes: number;
+    /**
+     * Bounded sample covering distinct formats first, then the largest files. A
+     * size-ordered sample would bury the metadata sheet, the README, and the paper —
+     * one file each — under whatever large files failed to group.
+     */
+    readonly sample: readonly UnstructuredEntry[];
+}
+/** How many files carry each detected format, across the whole scanned tree. */
+export interface FormatCount {
+    readonly format: string;
+    readonly count: number;
+}
+/**
+ * The agent-facing manifest: bounded by construction, so injecting it into a briefing
+ * or returning it from `scan_inputs` costs a fixed amount of context whatever the tree
+ * size. The complete per-file list lives on {@link InputScan}, host-side.
+ */
+export interface InputScanManifest {
+    /** Path scanned, relative to the analysis root. */
+    readonly root: string;
+    readonly fileCount: number;
+    readonly totalBytes: number;
+    /**
+     * True when the walk hit its file ceiling and stopped. The shapes below then
+     * describe a prefix of the tree, not all of it — stated rather than silently
+     * sampled.
+     */
+    readonly truncated: boolean;
+    /** The ceiling that bound, when `truncated`. */
+    readonly scanLimit?: number;
+    /** True when the shape list itself was capped; the remainder is folded into `unstructured`. */
+    readonly shapesTruncated: boolean;
+    readonly formats: readonly FormatCount[];
+    readonly shapes: readonly FileShape[];
+    readonly valueOverlaps: readonly ShapeValueOverlap[];
+    readonly unstructured: UnstructuredFiles;
+}
+/**
+ * The scan's full result. `files` is the complete enumeration — it stays host-side and
+ * backs coverage and the index projection; `manifest` is the bounded projection the
+ * agent reads.
+ */
+export interface InputScan {
+    readonly files: readonly ScannedFile[];
+    readonly manifest: InputScanManifest;
+    /**
+     * Per shape, the COMPLETE value set of each variable position, keyed by shape id.
+     * Bounded output belongs to the manifest; the entity tier of the index needs every
+     * value, and re-deriving them from filenames downstream would duplicate the
+     * tokenisation.
+     */
+    readonly positionValues: ReadonlyMap<string, readonly (readonly string[])[]>;
+}

package/dist/input-scan/types.js

@@ -0,0 +1,12 @@
+/**
+ * Input-scan vocabulary.
+ *
+ * The scan reports what is OBSERVABLE about a staged input tree; it never decides
+ * how the tree is grouped (see the input-scan-manifest spec). That separation is
+ * carried by the vocabulary itself: a shape is "these filenames differ only here",
+ * a kind is "these files are the same sort of thing", and only the profiler agent
+ * can establish the second. Nothing here is named `kinds` or `axes`, and no type
+ * here is assignable to the profiler's output — a manifest an agent could copy
+ * into its submission would make its central judgement invisible.
+ */
+export {};

package/dist/lib/zod-issues.d.ts

@@ -13,10 +13,9 @@
  *    ` ```json {…}``` `). The payload is complete; only the wrapper makes it a
  *    string.
  *
- * This module owns both halves of the response for the four model-facing
+ * This module owns both halves of the response for the three model-facing
  * validation sites (`loop/run-agent.ts`'s tool-input boundary,
- * `execution/run-synthesis.ts`, `tools/research/generate-plan.ts`,
- * `tools/iterate-report.ts`):
+ * `execution/run-synthesis.ts`, `tools/research/generate-plan.ts`):
  *
  *  - `hintForZodIssue` — a **diagnostic only**. It parses nothing into the
  *    caller's data; it distinguishes the two modes so the message the model

package/dist/lib/zod-issues.js

@@ -13,10 +13,9 @@
  *    ` ```json {…}``` `). The payload is complete; only the wrapper makes it a
  *    string.
  *
- * This module owns both halves of the response for the four model-facing
+ * This module owns both halves of the response for the three model-facing
  * validation sites (`loop/run-agent.ts`'s tool-input boundary,
- * `execution/run-synthesis.ts`, `tools/research/generate-plan.ts`,
- * `tools/iterate-report.ts`):
+ * `execution/run-synthesis.ts`, `tools/research/generate-plan.ts`):
  *
  *  - `hintForZodIssue` — a **diagnostic only**. It parses nothing into the
  *    caller's data; it distinguishes the two modes so the message the model

package/dist/loop/__fixtures__/scripted-provider.js

@@ -14,9 +14,11 @@ function mapFinishReason(finishReason) {
     }
 }
 export function makeMessage(content, finishReason, usage) {
+    const mapped = mapFinishReason(finishReason);
     return {
         message: { role: "assistant", content },
-        finishReason: mapFinishReason(finishReason),
+        finishReason: mapped,
+        ...(mapped === finishReason ? {} : { rawFinishReason: finishReason }),
         usage,
     };
 }

package/dist/loop/run-agent.d.ts

@@ -8,6 +8,11 @@ import { type AgentRunUsage } from "./metrics.js";
 import type { AgentDefinition, EmitFn, LoopMessage, RunStep } from "./types.js";
 export interface AgentFinish {
     readonly reason: FinishReason | "aborted" | "max_iterations" | "denied";
+    /**
+     * The endpoint's own word for the stop, when the provider captured one —
+     * `reason` normalizes it (an Anthropic `refusal` becomes `content-filter`).
+     */
+    readonly rawFinishReason?: string;
     readonly cappedOut: boolean;
     readonly truncationRecoveries: number;
     /**

package/dist/loop/run-agent.js

@@ -307,7 +307,16 @@ export async function runAgent(agent, initial, session, opts) {
             await emit({ type: "iteration", source, index: i, final: true });
             recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
             logFinish("info", reply.finishReason, false);
-            return { messages, finish: { reason: reply.finishReason, cappedOut: false, truncationRecoveries, ...finishUsage() } };
+            return {
+                messages,
+                finish: {
+                    reason: reply.finishReason,
+                    ...(reply.rawFinishReason === undefined ? {} : { rawFinishReason: reply.rawFinishReason }),
+                    cappedOut: false,
+                    truncationRecoveries,
+                    ...finishUsage(),
+                },
+            };
         }
         await emit({ type: "iteration", source, index: i, final: false });
         log.debug("iteration", { iteration: i, tools: toolCalls.map((t) => t.toolName) });

package/dist/loop/run-to-terminal.d.ts

@@ -2,7 +2,7 @@
  * `runToTerminal` — terminal-salvage wrapper around `runAgent`.
  *
  * Some agents communicate their result EXCLUSIVELY through a terminal tool
- * (`submit_plan`, `submit_report`, `submit_profile`, `submit_synthesis`, …):
+ * (`submit_plan`, `submit_profile`, `submit_synthesis`, …):
  * the loop's text reply is discarded and the outcome is read from a closure
  * cell the terminal tool writes. Plain `runAgent` ends a capped run on a
  * tool-LESS wrap-up turn, so an agent that burns its whole iteration budget —

package/dist/loop/run-to-terminal.js

@@ -2,7 +2,7 @@
  * `runToTerminal` — terminal-salvage wrapper around `runAgent`.
  *
  * Some agents communicate their result EXCLUSIVELY through a terminal tool
- * (`submit_plan`, `submit_report`, `submit_profile`, `submit_synthesis`, …):
+ * (`submit_plan`, `submit_profile`, `submit_synthesis`, …):
  * the loop's text reply is discarded and the outcome is read from a closure
  * cell the terminal tool writes. Plain `runAgent` ends a capped run on a
  * tool-LESS wrap-up turn, so an agent that burns its whole iteration budget —

package/dist/memory/card-builders.d.ts

@@ -39,14 +39,6 @@ export interface RunCardData {
     title: string;
     stepCount: number;
 }
-export interface PreviewCardData {
-    id: string;
-    previewId: string;
-    version: number;
-    title: string;
-    previewPath: string;
-    format: "html" | "pdf";
-}
 /** Build the `data-plan` payload by loading the stored plan. `ok(null)` when
  *  the plan is missing or no longer parses (absence is NOT an error) — the
  *  caller falls back to a chip. */
@@ -100,22 +92,3 @@ export declare function fileGroupHash(paths: string[], title: string | undefined
  * path the live tool rejected would be resurrected into a card on reload.
  */
 export declare function buildFileReferenceCardData(input: Record<string, unknown>): FileReferenceCardData | null;
-/**
- * Build the `data-report-preview` payload for an `iterate_report` tool_use. The
- * preview's source of truth is the filesystem under
- * `previews/{previewId}/`: directory layout yields `version`
- * (latest `vN`) + `previewPath`, and `preview-meta.json` yields title/format.
- * Mirrors `buildRunCardData` — the live emit knows the server-generated
- * `previewId`, while the reconstruct-on-read path resolves it (from the
- * iteration's `previewId` input, or else the analysis's latest preview). The
- * card is keyed by `previewId` only, so every iteration's tool_use rebuilds
- * the same card and the frontend groups them into one with all versions selectable.
- * Null when nothing renders — the caller falls back to a chip.
- */
-export declare function buildPreviewCardData(
-/** Absolute host root of the analysis's workspace tree (previews live inside it). */
-workspaceRoot: string, opts: {
-    previewId?: string;
-    title?: string;
-    format?: "html" | "pdf";
-}): Promise<PreviewCardData | null>;

package/dist/memory/card-builders.js

@@ -16,17 +16,12 @@
  * under the part `type` directly.
  */
 import { createHash } from "node:crypto";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
 import { okAsync } from "neverthrow";
 import { tryQuery } from "../lib/db-result.js";
-import { tryFs } from "../lib/fs-result.js";
 import { AnalysisPlanSchema } from "../schemas/workflow-state.js";
 import { loadPlan } from "../state/index.js";
 import { normalizeEchartSpec } from "../tools/display/normalize-echart-spec.js";
 import { validatePath } from "../tools/lib/path-validation.js";
-import { latestPreviewVersion, previewDir, PREVIEWS_ROOT } from "../workspace/paths.js";
-const PREVIEW_META_FILE = "preview-meta.json";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -176,73 +171,3 @@ export function buildFileReferenceCardData(input) {
     const id = `pres-${fileGroupHash(files.map((f) => f.path), title)}`;
     return { id, ...(title !== undefined ? { title } : {}), files };
 }
-/** The stored preview metadata, or `null` when the file is absent — a malformed
- *  file is a genuine read failure (`err`), folded to `null` at the call site. */
-function readPreviewMeta(previewRootAbs) {
-    const path = join(previewRootAbs, PREVIEW_META_FILE);
-    return tryFs("cardBuilders.readPreviewMeta", async () => JSON.parse(await readFile(path, "utf8")), { path, onAbsent: () => null });
-}
-/** Directory names (not files) directly under `dir`, or `[]` when absent. */
-function subdirs(dir) {
-    return tryFs("cardBuilders.subdirs", async () => (await readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name), {
-        path: dir,
-        onAbsent: () => [],
-    });
-}
-/** The most-recently-modified previewId under an analysis, or null when none. */
-function latestPreviewId(previewsRootAbs) {
-    return subdirs(previewsRootAbs).map(async (dirs) => {
-        if (dirs.length <= 1)
-            return dirs[0] ?? null;
-        let best = null;
-        for (const name of dirs) {
-            const path = join(previewsRootAbs, name);
-            const mtimeMs = await tryFs("cardBuilders.latestPreviewId.stat", async () => (await stat(path)).mtimeMs, { path }).unwrapOr(null); // skip an unreadable/absent entry
-            if (mtimeMs !== null && (!best || mtimeMs > best.mtimeMs)) {
-                best = { name, mtimeMs };
-            }
-        }
-        return best?.name ?? dirs[0];
-    });
-}
-/**
- * Build the `data-report-preview` payload for an `iterate_report` tool_use. The
- * preview's source of truth is the filesystem under
- * `previews/{previewId}/`: directory layout yields `version`
- * (latest `vN`) + `previewPath`, and `preview-meta.json` yields title/format.
- * Mirrors `buildRunCardData` — the live emit knows the server-generated
- * `previewId`, while the reconstruct-on-read path resolves it (from the
- * iteration's `previewId` input, or else the analysis's latest preview). The
- * card is keyed by `previewId` only, so every iteration's tool_use rebuilds
- * the same card and the frontend groups them into one with all versions selectable.
- * Null when nothing renders — the caller falls back to a chip.
- */
-export async function buildPreviewCardData(
-/** Absolute host root of the analysis's workspace tree (previews live inside it). */
-workspaceRoot, opts) {
-    const previewsRootAbs = join(workspaceRoot, PREVIEWS_ROOT);
-    const resolveId = opts.previewId ? okAsync(opts.previewId) : latestPreviewId(previewsRootAbs);
-    return resolveId
-        .andThen((previewId) => {
-        if (!previewId)
-            return okAsync(null);
-        const previewRootAbs = join(workspaceRoot, previewDir(previewId));
-        return subdirs(previewRootAbs).andThen((versionDirs) => {
-            const version = latestPreviewVersion(versionDirs);
-            if (version === 0)
-                return okAsync(null);
-            return readPreviewMeta(previewRootAbs).map((meta) => {
-                const id = `prev-${createHash("sha256").update(previewId).digest("hex").slice(0, 16)}`;
-                return {
-                    id,
-                    previewId,
-                    version,
-                    title: opts.title ?? meta?.title ?? "Report",
-                    previewPath: `v${version}/index.html`,
-                    format: opts.format ?? (meta?.format === "pdf" ? "pdf" : "html"),
-                };
-            });
-        });
-    })
-        .unwrapOr(null);
-}

package/dist/memory/conversation-display-backfill.d.ts

@@ -1,9 +1,7 @@
 import type { Pool } from "pg";
 import type { Tool } from "../tools/define-tool.js";
-import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 export interface ConversationDisplayBackfillDeps {
     readonly pool: Pool;
-    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
     /**
      * The conversation agent's composed roster, used to recover each legacy call's
      * one-line detail from its persisted input. Tools contributed through the
@@ -17,8 +15,8 @@ export interface ConversationDisplayBackfillDeps {
  * Freeze the migration renderer's output into display envelopes, once per legacy
  * turn, so the runtime read path never has to reconstruct anything.
  *
- * Missing mutable resources degrade to a generic, cardless display — a workspace
- * that has moved is normal historical absence, not a fault. Malformed stored rows
+ * Missing mutable resources degrade to a generic, cardless display — a plan
+ * that is absent is normal historical absence, not a fault. Malformed stored rows
  * and database faults remain startup-fatal: a turn that cannot be migrated must
  * not be silently skipped and then read as if it had no display.
  */