@inflexa-ai/harness 0.28.0 → 0.29.0

package/dist/tools/research/inspect-data-profile.js

@@ -8,13 +8,16 @@
  * **There is no data-profile file.** The profiler's `runs/data-profile/` scratch tree
  * is deleted when profiling completes; the profile's only durable home is the
  * `cortex_analysis_state` row this tool reads. That makes this the single authoritative
- * source for dataset facts (organism, domain, design, per-file type/format/dimensions),
- * and it is why the record is served in full rather than summarized: an agent that
- * cannot pull a fact here has no fallback but to re-derive it from the raw bytes.
+ * source for dataset facts — the identity fields, the resolved groups with their slots,
+ * the dimensions with their observations, and the partition census — and it is why the
+ * record is served in full rather than summarized: an agent that cannot pull a fact here
+ * has no fallback but to re-derive it from the raw bytes.
  *
- * Bounded by construction. Like `inspect_run`, the per-file scope is explicitly
- * paged and always reports `total` and `hasMore`: an elided tail is a fact the
- * model can see and act on, never a silent truncation.
+ * Bounded by construction. Like `inspect_run`, the member scope is explicitly paged and
+ * always reports `total` and `hasMore`: an elided tail is a fact the model can see and
+ * act on, never a silent truncation. The annotated-member count and the dataset's file
+ * count are reported as two distinct figures, because a profile annotating eight members
+ * of several thousand files is correct and a single number would read as a tiny dataset.
  *
  * Lifecycle states are data variants, not errors (the `defineTool` contract): a missing,
  * in-flight, failed, or stale profile is an ordinary, expected outcome the model must be
@@ -28,6 +31,7 @@
  */
 import { ok } from "neverthrow";
 import { z } from "zod";
+import { profileCaveats, profileDatasetFileCount, profileFileRecords, profileGroups } from "../../app/data-profile-view.js";
 import { scopeResource } from "../../auth/types.js";
 import { unwrapOrThrow } from "../../lib/result.js";
 import { loadDataProfileStatus } from "../../state/index.js";
@@ -37,31 +41,19 @@ import { defineTool } from "../define-tool.js";
 const DEFAULT_PAGE_SIZE = 20;
 /** Ceiling on `pageSize` — a page is a context-window budget, not a dump. */
 const MAX_PAGE_SIZE = 100;
-/**
- * How many files the dataset holds, as far as the snapshot can establish it.
- *
- * Coverage counts the scanned tree, so it is the authority where present. Summed kind
- * counts are the fallback. A snapshot with neither returns `null` rather than the
- * described-file count, which would be a dataset size the row cannot support.
- */
-function datasetFileCount(result) {
-    if (result.coverage)
-        return result.coverage.total;
-    if (result.kinds && result.kinds.length > 0)
-        return result.kinds.reduce((sum, kind) => sum + kind.count, 0);
-    return null;
-}
 /** Serve each per-file record with a path that resolves in the frame of the caller. */
 function rootFilePaths(files, analysisId) {
     return files.map((file) => ({ ...file, path: toAnalysisRootPath(analysisId, file.path) }));
 }
 /**
- * Serve each kind with a glob that resolves in the frame of the caller.
+ * Serve each group with a display pattern that resolves in the frame of the caller.
  *
- * A `pathPattern` is a path with a wildcard segment, thus it takes the same
- * projection as a file path. The wildcard characters survive it: the projection
- * only re-roots the pattern.
+ * A pattern is a path with varying segments, thus it takes the same projection as a file
+ * path. Its placeholders survive it: the projection only re-roots the pattern.
  */
+function rootGroupPatterns(groups, analysisId) {
+    return groups.map((group) => ({ ...group, displayPattern: toAnalysisRootPath(analysisId, group.displayPattern) }));
+}
 function rootKindPatterns(kinds, analysisId) {
     return kinds.map((kind) => ({ ...kind, pathPattern: toAnalysisRootPath(analysisId, kind.pathPattern) }));
 }
@@ -103,20 +95,21 @@ export function createInspectDataProfileTool(pool) {
         id: "inspect_data_profile",
         description: "Read this analysis's data profile — the AUTHORITATIVE record of what the input dataset is: " +
             "organism and taxon id, scientific domain and subtype, tissue, cell type, condition, experimental design, " +
-            "dataset-wide quality concerns and strengths, public accessions, the KINDS of file the dataset is made of " +
-            "and what varies across them, and per-file data type, format, row/column dimensions, tags and warnings for " +
-            "the files described individually. " +
+            "dataset-wide caveats, public accessions, the GROUPS of file the dataset is made of, the DIMENSIONS that vary " +
+            "across it with the evidence behind each, and the file census (kept, unclassified, quarantined). " +
             "There is NO data-profile file in the workspace — this tool is the only way to read it. Do not search for one, " +
             "and do not rediscover these facts by listing or reading the raw input files. " +
             "Call it before you reason about the data (planning, writing analysis code, interpreting results). " +
-            "scope:'overview' (the default) returns the dataset-level orientation, how many files are described individually, " +
-            "and how many files the dataset holds — those two differ on purpose, because a large dataset is described by its " +
-            "kinds rather than file by file. " +
-            "scope:'kinds' returns those kinds with their counts, path patterns, and axes — this is where a dataset of thousands " +
-            "of files is described. A profile taken before kinds existed reports the scope unavailable. " +
-            "scope:'files' returns the individually described files, paged: page (1-based, default 1) and pageSize (default 20, max 100), " +
+            "scope:'overview' (the default) returns the dataset-level orientation plus the partition accounting — how many " +
+            "files were kept, how many landed in no group, how many were quarantined — and how many members are described " +
+            "individually. That last figure and the dataset's file count differ on purpose: a large dataset is described by " +
+            "its groups, not file by file. " +
+            "scope:'groups' returns the groups with their derived counts, display patterns, and slots, plus the dimensions " +
+            "with their observations, reconciliations, and probe outcomes — this is where a dataset of thousands of files is " +
+            "described. A profile written under the previous model returns its kinds and axes, labelled as such. " +
+            "scope:'files' returns the individually annotated members, paged: page (1-based, default 1) and pageSize (default 20, max 100), " +
             "always with the true total and hasMore, so you can see exactly what you have not read yet. " +
-            "For the paths of files no record describes, list the workspace tree. " +
+            "For the paths of files no record describes, use scope:'groups' for the structure and list the workspace tree for the paths. " +
             "The state field says what you got: 'ready'; 'stale' (a profile is returned but may not describe the current " +
             "inputs — staleReason says why); 'pending' (profiling is still running); 'failed'; or 'absent' (never profiled, " +
             "or the analysis has no input files). " +
@@ -126,19 +119,19 @@ export function createInspectDataProfileTool(pool) {
             "needs re-running rather than diagnosing the data itself.",
         inputSchema: z.object({
             scope: z
-                .enum(["overview", "kinds", "files"])
+                .enum(["overview", "groups", "files"])
                 .optional()
-                .describe("'overview' (default): dataset-level facts, described-file count, and dataset file count. " +
-                "'kinds': the sets the dataset is made of and what varies across them. " +
-                "'files': paged records for the individually described files."),
-            page: z.number().int().min(1).optional().describe("1-based page of per-file records. Only used when scope is 'files'. Default 1."),
+                .describe("'overview' (default): dataset-level facts, the partition accounting, the annotated-member count, and the dataset file count. " +
+                "'groups': the groups the dataset is made of, with their slots, and the dimensions that vary across it. " +
+                "'files': paged records for the individually annotated members."),
+            page: z.number().int().min(1).optional().describe("1-based page of member records. Only used when scope is 'files'. Default 1."),
             pageSize: z
                 .number()
                 .int()
                 .min(1)
                 .max(MAX_PAGE_SIZE)
                 .optional()
-                .describe(`Per-file records per page. Only used when scope is 'files'. Default ${DEFAULT_PAGE_SIZE}, max ${MAX_PAGE_SIZE}.`),
+                .describe(`Member records per page. Only used when scope is 'files'. Default ${DEFAULT_PAGE_SIZE}, max ${MAX_PAGE_SIZE}.`),
         }),
         // `execute` defaults both fields internally, and the hook applies the same
         // defaults. Without them the ordinary call, which names no field at all,
@@ -160,8 +153,8 @@ export function createInspectDataProfileTool(pool) {
                 if (status.status === "failed") {
                     // A failure that DID leave a prior profile on the row never reaches
                     // here — it is served as `stale`, where `stalenessReasons` names the
-                    // failed re-profile and compares the input sets through the single
-                    // shared predicate. This branch is the case with nothing to compare.
+                    // failed re-profile. This branch is the case with no prior profile to
+                    // serve at all.
                     return ok({
                         state: "failed",
                         error: status.error,
@@ -188,14 +181,16 @@ export function createInspectDataProfileTool(pool) {
                 ? { state: "stale", staleReason: reasons.join("; "), profiledAt: result.profiledAt }
                 : { state: "ready", profiledAt: result.profiledAt };
             const scope = input.scope ?? "overview";
+            const describedFiles = profileFileRecords(result);
+            const groups = profileGroups(result);
             if (scope === "overview") {
-                const dataset = datasetFileCount(result);
-                const described = result.files.length;
+                const dataset = profileDatasetFileCount(result);
+                const described = describedFiles.length;
                 const structureNote = dataset === null
                     ? "This profile predates the dataset-structure record, so only the individually described files are known; " +
                         "list the workspace tree for the rest."
                     : dataset !== described
-                        ? `${described} of ${dataset} files are described individually. Call scope:'kinds' for what the rest are, ` +
+                        ? `${described} of ${dataset} files are described individually. Call scope:'groups' for what the rest are, ` +
                             "and list the workspace tree for their paths."
                         : undefined;
                 return ok({
@@ -209,40 +204,63 @@ export function createInspectDataProfileTool(pool) {
                     cellType: result.cellType,
                     condition: result.condition,
                     experimentalDesign: result.experimentalDesign,
-                    qualityAssessment: result.qualityAssessment,
+                    caveats: profileCaveats(result),
                     accessions: result.accessions,
                     describedFileCount: described,
                     datasetFileCount: dataset,
-                    kindCount: result.kinds ? result.kinds.length : null,
+                    // Presence, not truthiness: a completed profile over a tree the scan kept
+                    // nothing of carries `groups: []`, and "zero groups" is a finding — reading
+                    // it as "no structure record" would report the analysis unprofiled.
+                    groupCount: result.groups !== undefined || result.kinds !== undefined ? groups.length : null,
                     ...(structureNote ? { structureNote } : {}),
+                    ...(result.partition ? { partition: result.partition } : {}),
                     ...(result.coverage ? { coverage: result.coverage } : {}),
                 });
             }
-            if (scope === "kinds") {
-                if (!result.kinds) {
+            if (scope === "groups") {
+                if (result.groups !== undefined) {
+                    return ok({
+                        ...envelope,
+                        scope: "groups",
+                        available: true,
+                        groups: rootGroupPatterns(result.groups, resourceId),
+                        ...(result.dimensions ? { dimensions: result.dimensions } : {}),
+                        ...(result.probes ? { probes: result.probes } : {}),
+                        ...(result.partition ? { partition: result.partition } : {}),
+                        ...(result.recipe ? { recipe: result.recipe } : {}),
+                    });
+                }
+                if (result.kinds === undefined) {
                     return ok({
                         ...envelope,
-                        scope: "kinds",
+                        scope: "groups",
                         available: false,
-                        message: "This profile was taken before the dataset-structure record existed, so it carries no kinds. " +
+                        message: "This profile was taken before the dataset-structure record existed, so it carries no groups. " +
                             "That is a fact about the profile, not about the dataset: use scope:'files' and the workspace " +
                             "listing tools, or re-profile the analysis.",
                     });
                 }
+                // The structure exists; only its vocabulary is older. Serving it labelled beats
+                // reporting the scope unavailable, which would tell an agent the dataset has no
+                // structure when the row plainly holds some.
                 return ok({
                     ...envelope,
-                    scope: "kinds",
+                    scope: "groups",
                     available: true,
+                    legacy: true,
                     kinds: rootKindPatterns(result.kinds, resourceId),
                     ...(result.axes ? { axes: result.axes } : {}),
                     ...(result.coverage ? { coverage: result.coverage } : {}),
+                    message: "Authored under the previous model: these are kinds and axes, not resolved groups and dimensions. " +
+                        "Counts and patterns were the profiler's own claims rather than a computed partition, and there is no " +
+                        "unclassified sweep or quarantine accounting on a profile of that era.",
                 });
             }
             const pageSize = input.pageSize ?? DEFAULT_PAGE_SIZE;
             const page = input.page ?? 1;
-            const total = result.files.length;
+            const total = describedFiles.length;
             const start = (page - 1) * pageSize;
-            const files = result.files.slice(start, start + pageSize);
+            const files = describedFiles.slice(start, start + pageSize);
             return ok({
                 ...envelope,
                 scope: "files",
@@ -250,6 +268,7 @@ export function createInspectDataProfileTool(pool) {
                 pageSize,
                 total,
                 hasMore: start + files.length < total,
+                datasetFileCount: profileDatasetFileCount(result),
                 files: rootFilePaths(files, resourceId),
             });
         },

package/dist/tools/workspace/scan-inputs.d.ts

@@ -7,9 +7,9 @@
  * with the observed shapes, or wants a directory the injected manifest summarised, can
  * get the evidence to group differently.
  *
- * Dependency-bearing factory. The walk and the shape observation run in-process over
- * the workspace read seam; only the per-shape header readout reaches into the sandbox
- * (see `input-scan/enrich.ts`).
+ * Dependency-bearing factory. The walk, the shape observation, and every
+ * prefix-sufficient header readout run in-process over the workspace read seam; only a
+ * footer-indexed container reaches into the sandbox (see `input-scan/enrich.ts`).
  */
 import type { SandboxClient } from "../../sandbox/client.js";
 import type { SandboxRef } from "../../sandbox/types.js";
@@ -17,7 +17,7 @@ import type { WorkspaceFilesystem } from "../../workspace/filesystem.js";
 export interface ScanInputsDeps {
     readonly workspaceFs: WorkspaceFilesystem;
     readonly analysisId: string;
-    /** Omit to run the host-side scan with no header readout (no sandbox wired). */
+    /** Omit to skip the container readouts; the prefix readouts run regardless. */
     readonly sandboxClient?: SandboxClient;
     readonly sandbox?: SandboxRef;
     readonly workflowId: string;

package/dist/tools/workspace/scan-inputs.js

@@ -7,9 +7,9 @@
  * with the observed shapes, or wants a directory the injected manifest summarised, can
  * get the evidence to group differently.
  *
- * Dependency-bearing factory. The walk and the shape observation run in-process over
- * the workspace read seam; only the per-shape header readout reaches into the sandbox
- * (see `input-scan/enrich.ts`).
+ * Dependency-bearing factory. The walk, the shape observation, and every
+ * prefix-sufficient header readout run in-process over the workspace read seam; only a
+ * footer-indexed container reaches into the sandbox (see `input-scan/enrich.ts`).
  */
 import { ok } from "neverthrow";
 import { z } from "zod";
@@ -38,17 +38,16 @@ export function createScanInputsTool(deps) {
                 root: path.replace(/^\/+/, "").replace(/\/+$/, ""),
                 signal: ctx.signal,
             });
-            const shapes = deps.sandboxClient && deps.sandbox
-                ? await enrichShapes({
-                    shapes: scan.manifest.shapes,
-                    sandboxClient: deps.sandboxClient,
-                    sandbox: deps.sandbox,
-                    mountRoot: `/${deps.analysisId}`,
-                    execId: `${deps.workflowId}:${deps.stepId}:${deps.nextFunctionId()}`,
-                    deadlineMs: deps.deadlineMs(),
-                    emit: ctx.emit,
-                })
-                : scan.manifest.shapes;
+            const shapes = await enrichShapes({
+                shapes: scan.manifest.shapes,
+                session: ctx.session,
+                fs: deps.workspaceFs,
+                ...(deps.sandboxClient && deps.sandbox ? { sandboxClient: deps.sandboxClient, sandbox: deps.sandbox } : {}),
+                mountRoot: `/${deps.analysisId}`,
+                execId: `${deps.workflowId}:${deps.stepId}:${deps.nextFunctionId()}`,
+                deadlineMs: deps.deadlineMs(),
+                emit: ctx.emit,
+            });
             const manifest = { ...scan.manifest, shapes };
             return ok({
                 path: manifest.root,

package/dist/tools/workspace/workspace-search.d.ts

@@ -12,14 +12,23 @@
  */
 import type { Pool } from "pg";
 import type { EmbeddingProvider } from "../../providers/types.js";
+/**
+ * The workspace path a hit addresses, or `undefined` for a pattern entry. Resolved here,
+ * once, across every index era — group/dimension/kind entries and previous-era entity
+ * entries (`entity` in metadata) are patterns; everything else is a file whose path is
+ * stamped in metadata or, on rows older than the stamp, is the id minus the resource
+ * segment. The consumer branches on presence, nothing else.
+ */
+export declare function fileTargetOf(id: string, metadata: unknown): string | undefined;
 export declare function createWorkspaceSearchTool(pool: Pool, embedding: EmbeddingProvider): import("../define-tool.js").Tool<{
     query: string;
     limit: number;
-    type?: "output" | "input" | "synthesis" | "summary" | "input-kind" | undefined;
+    type?: "output" | "input" | "synthesis" | "summary" | "input-group" | "input-dimension" | "input-kind" | undefined;
 }, {
     results: {
+        metadata: unknown;
+        path?: string | undefined;
         id: string;
         score: number;
-        metadata: unknown;
     }[];
 }>;

package/dist/tools/workspace/workspace-search.js

@@ -29,25 +29,49 @@ function indexName(analysisId) {
     }
     return name;
 }
+/** Entry types that address a pattern spanning many files, never a single one. */
+const PATTERN_TYPES = new Set(["input-group", "input-dimension", "input-kind"]);
+/**
+ * The workspace path a hit addresses, or `undefined` for a pattern entry. Resolved here,
+ * once, across every index era — group/dimension/kind entries and previous-era entity
+ * entries (`entity` in metadata) are patterns; everything else is a file whose path is
+ * stamped in metadata or, on rows older than the stamp, is the id minus the resource
+ * segment. The consumer branches on presence, nothing else.
+ */
+export function fileTargetOf(id, metadata) {
+    const meta = metadata && typeof metadata === "object" ? metadata : {};
+    const type = typeof meta.type === "string" ? meta.type : undefined;
+    if (type !== undefined && PATTERN_TYPES.has(type))
+        return undefined;
+    if (type === "input" && meta.entity !== undefined)
+        return undefined;
+    if (typeof meta.path === "string")
+        return meta.path;
+    return id.replace(/^\/[^/]+\//, "");
+}
 export function createWorkspaceSearchTool(pool, embedding) {
     return defineTool({
         id: "workspace_search",
         description: "Semantic search over the analysis workspace. Returns ranked entries with descriptions " +
-            "and metadata; read a file separately to see its contents. Indexed entries are exactly " +
-            'five types, and `type` restricts results to one of them: "input-kind" (a KIND of input ' +
-            "data — a repeating set the data profiler named, carrying its count and a pathPattern " +
-            'matching its members), "input" (one entity the dataset is about — a subject, sample, or ' +
-            'other axis value — with the kinds of file it carries), "output" (files a step produced), ' +
-            '"summary" (a step\'s summary), "synthesis" (a run\'s literature-grounded synthesis). ' +
-            "For output/summary/synthesis the entry id IS the workspace path; for the two input types " +
-            "it is not, because a kind and an entity each span many files — search input-kind for a " +
-            "set's pathPattern, then list the tree for its members.",
+            "and metadata; read a file separately to see its contents. `type` restricts results to one " +
+            'entry type: "input-group" (a GROUP of input data the data profiler declared, carrying its ' +
+            'derived count, its display pattern, and its slots), "input-dimension" (something that VARIES ' +
+            "across the dataset — subject, timepoint, batch — with the observations evidencing it), " +
+            '"input" (one input file the profiler annotated individually, or, on a profile of the ' +
+            'previous era, one entity the dataset is about), "output" (files a step produced), ' +
+            '"summary" (a step\'s summary), "synthesis" (a run\'s literature-grounded synthesis), ' +
+            '"input-kind" (a repeating set, on a profile of the previous era). ' +
+            "A hit carrying `path` is a FILE — read that path to see its contents. A hit without " +
+            "`path` is a PATTERN spanning many files (a group, a dimension, an entity): use its " +
+            "metadata, e.g. search input-group for a group's display pattern, then list the tree for " +
+            "its members. Most input files carry no entry of their own — find them through their " +
+            "group and the listing tools.",
         inputSchema: z.object({
             query: z.string().min(1).describe("What to search for, in natural language"),
             type: z
-                .enum(["input-kind", "input", "output", "summary", "synthesis"])
+                .enum(["input-group", "input-dimension", "input", "input-kind", "output", "summary", "synthesis"])
                 .optional()
-                .describe('Restrict results to one entry type: "input-kind", "input", "output", "summary", or "synthesis"'),
+                .describe('Restrict results to one entry type: "input-group", "input-dimension", "input", "input-kind", "output", "summary", or "synthesis"'),
             limit: z.number().int().min(1).max(50).default(8).describe("Maximum number of results to return"),
         }),
         describeCall: ({ query, type }) => (type === undefined ? query : `${query} (${type})`),
@@ -77,11 +101,15 @@ export function createWorkspaceSearchTool(pool, embedding) {
             // exist. That is absence, not a failure: recover into ok([]).
             isUndefinedTable(e.cause) ? okAsync([]) : err(e)));
             return ok({
-                results: rows.map((r) => ({
-                    id: r.id,
-                    score: r.score,
-                    metadata: r.metadata,
-                })),
+                results: rows.map((r) => {
+                    const path = fileTargetOf(r.id, r.metadata);
+                    return {
+                        id: r.id,
+                        score: r.score,
+                        ...(path !== undefined ? { path } : {}),
+                        metadata: r.metadata,
+                    };
+                }),
             });
         },
     });

package/dist/workflows/sandbox-step.js

@@ -500,16 +500,46 @@ export async function runSandboxStepBody(input, deps) {
     // outputs, so it fails the step loudly instead of finishing green. Transient
     // managed-root errors are already retried in the client, so anything thrown here is
     // persistent — tear down, mark failed, and re-raise so the parent's fail-fast
-    // cascade fires (mirrors the agent-loop failure path).
+    // cascade fires (mirrors the agent-loop failure path). The two operations are
+    // sequenced independently: byte-sync is attempted on both arms, so a rejected
+    // registration still uploads the bytes of whatever DID register.
     await emitActivity("persisting", "Registering artifacts");
+    // A bare call, deliberately not `DBOS.runStep`-wrapped: it is reachable from
+    // two arms below, and a checkpointed step reached from a conditional arm
+    // would shift the body's function-ID sequence between the two paths (see the
+    // harness-durable-runtime spec).
+    const syncStepArtifacts = () => deps.artifactRegistry.sync({
+        resourceId: input.analysisId,
+        runId: input.runId,
+        stepId: input.stepId,
+    }, session);
     let reconciledManifest;
     try {
         reconciledManifest = await reconcileAndRegisterStepArtifacts(deps, postCtx, manifest);
-        await deps.artifactRegistry.sync({
-            resourceId: input.analysisId,
-            runId: input.runId,
-            stepId: input.stepId,
-        }, session);
+    }
+    catch (registrationErr) {
+        // Registration and byte-sync are independent, and a registry rejection is
+        // partial: the rows that DID register carry `artifact_id` with `file_id`
+        // still NULL, which is exactly what `queryUnsyncedStepArtifacts` selects.
+        // Syncing anyway uploads their bytes (rows that never registered are not
+        // selected, so this stays idempotent under re-execution); skipping it is
+        // what strands them registered-but-byteless.
+        try {
+            await syncStepArtifacts();
+        }
+        catch (syncErr) {
+            // A cancellation is control-flow, not a sync failure — re-raise it
+            // verbatim, as every other stage in this body does. Any real failure
+            // is swallowed so it cannot displace the registration rejection as the
+            // step's cause; this record is the only account of it.
+            if (syncErr instanceof DBOSErrors.DBOSWorkflowCancelledError)
+                throw syncErr;
+            logger.named("post-step.sync").warn("failed after a registration rejection (non-fatal)", logger.errorFields(syncErr));
+        }
+        throw await failStep("lineage_attestation", registrationErr);
+    }
+    try {
+        await syncStepArtifacts();
     }
     catch (err) {
         throw await failStep("lineage_attestation", err);

package/dist/workflows/target-assessment/phase4-assemble.d.ts

@@ -124,6 +124,27 @@ export declare const Phase4OutputSchema: z.ZodObject<{
             coverage: z.ZodLiteral<"not_loaded">;
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "coverage">;
+        entity: z.ZodObject<{
+            canonicalId: z.ZodString;
+            symbol: z.ZodString;
+            displayName: z.ZodString;
+            entityType: z.ZodEnum<{
+                gene: "gene";
+                rna: "rna";
+                protein: "protein";
+                complex: "complex";
+            }>;
+            ontology: z.ZodString;
+            identifiers: z.ZodObject<{
+                hgnc: z.ZodOptional<z.ZodString>;
+                ensembl: z.ZodOptional<z.ZodString>;
+                uniprot: z.ZodOptional<z.ZodString>;
+                chembl: z.ZodOptional<z.ZodString>;
+                ncbiGene: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            synonyms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            proteinFamily: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
         off_target_panel: z.ZodDiscriminatedUnion<[z.ZodObject<{
             coverage: z.ZodLiteral<"available">;
             data: z.ZodObject<{
@@ -347,27 +368,6 @@ export declare const Phase4OutputSchema: z.ZodObject<{
             inferred_therapeutic_area: z.ZodNullable<z.ZodString>;
             no_liabilities_disclosure: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
-        entity: z.ZodObject<{
-            canonicalId: z.ZodString;
-            symbol: z.ZodString;
-            displayName: z.ZodString;
-            entityType: z.ZodEnum<{
-                gene: "gene";
-                rna: "rna";
-                protein: "protein";
-                complex: "complex";
-            }>;
-            ontology: z.ZodString;
-            identifiers: z.ZodObject<{
-                hgnc: z.ZodOptional<z.ZodString>;
-                ensembl: z.ZodOptional<z.ZodString>;
-                uniprot: z.ZodOptional<z.ZodString>;
-                chembl: z.ZodOptional<z.ZodString>;
-                ncbiGene: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>;
-            synonyms: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            proteinFamily: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
         indications: z.ZodDiscriminatedUnion<[z.ZodObject<{
             coverage: z.ZodLiteral<"available">;
             data: z.ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.28.0",
+    "version": "0.29.0",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -33,15 +33,17 @@
         "directory": "harness"
     },
     "scripts": {
-        "build": "tsc -p tsconfig.json",
+        "build": "tsc -p tsconfig.json && node scripts/copy-assets.mjs",
         "design:fixture": "bun scripts/render-fixture.ts",
         "format": "prettier --write src/",
         "format:file": "prettier --write",
         "lint": "eslint .",
-        "prepare": "tsc -p tsconfig.json",
+        "lint:python": "ruff check src/input-scan/decoder && ruff format --check src/input-scan/decoder",
+        "prepare": "tsc -p tsconfig.json && node scripts/copy-assets.mjs",
         "prepublishOnly": "bun run build && bun run smoke",
         "smoke": "node scripts/smoke.mjs",
         "test:full": "bash scripts/test-full.sh",
+        "test:python": "python3 -m pytest src/input-scan/decoder -q",
         "typecheck": "tsc --noEmit"
     },
     "dependencies": {

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

@@ -1,22 +0,0 @@
-/**
- * Profile coverage — how much of the scanned tree the agent's kinds actually describe.
- *
- * Measured against the SUBMITTED kinds, never against the scan's own shapes. Computed
- * from the shapes it would report only whether the scan grouped its own observations,
- * which is always yes; measured against the kinds it is a real check, and it is the
- * check that was missing when a profile covering 49 of 3513 files read as complete and
- * fresh.
- *
- * Deterministic by construction: matching declared patterns against a known file set
- * requires no judgement, and a coverage figure a model self-reported would not be a
- * check at all.
- */
-export interface ProfileCoverage {
-    /** Files matching at least one declared kind pattern. */
-    readonly matched: number;
-    readonly unmatched: number;
-    readonly total: number;
-    readonly unmatchedSample: string[];
-}
-/** Coverage of a scanned file set by a set of declared kind patterns. */
-export declare function computeCoverage(paths: readonly string[], patterns: readonly string[]): ProfileCoverage;