@inflexa-ai/harness 0.19.1 → 0.20.0

package/dist/state/analyses.js

@@ -1,5 +1,5 @@
 /**
- * `cortex_analysis_state` operations — analysis lifecycle and billing context.
+ * `cortex_analysis_state` operations — analysis lifecycle.
  */
 import { tryMutation, tryQuery } from "../lib/db-result.js";
 /**
@@ -7,40 +7,24 @@ import { tryMutation, tryQuery } from "../lib/db-result.js";
  *
  * The seed endpoint is called repeatedly; this function handles both the
  * initial INSERT and subsequent UPDATEs by writing ALL mutable fields on
- * every call. Re-upserts replace `context` and `billing_context` wholesale.
+ * every call. Re-upserts replace `context` wholesale.
  *
  * User identity is derived from the ambient credential's JWT `sub` claim
  * at request time — not persisted in this table.
- *
- * INTENTIONAL: split-attribution across a single run.
- * If the seed re-upserts mid-workflow (e.g., the billing context's VK rotates),
- * in-flight steps that have already issued LLM calls keep the old attribution
- * on those calls, while subsequent steps in the same run pick up the new
- * identity on their next `billedAgent` resolution. This is by design —
- * usage rows contain full per-call attribution, so spend is
- * always assignable even when it crosses a rotation boundary.
  */
-export function upsertAnalysis(pool, resourceId, context, billingContext, inputFileIds) {
+export function upsertAnalysis(pool, resourceId, context, inputFileIds) {
     const now = new Date().toISOString();
     return tryMutation("analyses.upsertAnalysis", async () => {
         await pool.query({
             text: `INSERT INTO cortex_analysis_state
-            (analysis_id, status, context, billing_context, data_profile_status,
+            (analysis_id, status, context, data_profile_status,
              seed_input_file_ids, created_at, updated_at)
-            VALUES ($1, 'active', $2, $3::jsonb, 'pending', $4::jsonb, $5, $6)
+            VALUES ($1, 'active', $2, 'pending', $3::jsonb, $4, $5)
             ON CONFLICT (analysis_id) DO UPDATE SET
               context = EXCLUDED.context,
-              billing_context = EXCLUDED.billing_context,
               seed_input_file_ids = COALESCE(EXCLUDED.seed_input_file_ids, cortex_analysis_state.seed_input_file_ids),
               updated_at = EXCLUDED.updated_at`,
-            values: [
-                resourceId,
-                context ?? null,
-                billingContext === null ? null : JSON.stringify(billingContext),
-                inputFileIds ? JSON.stringify(inputFileIds) : null,
-                now,
-                now,
-            ],
+            values: [resourceId, context ?? null, inputFileIds ? JSON.stringify(inputFileIds) : null, now, now],
         });
     });
 }
@@ -88,45 +72,3 @@ export function resumeAnalysis(pool, analysisId) {
         });
     });
 }
-/**
- * Resolve the persisted billing context for an analysis.
- *
- * Single DB-read chokepoint used by `requireAnalysisBilling` middleware and
- * by any downstream code that needs to re-read billing identity. The driver
- * read is wrapped as a `DbError`; the missing-row / null-billing /
- * unparseable-JSON cases are control-flow throws (a misconfiguration, not a
- * driver failure) that short-circuit the chain and surface verbatim.
- *
- * User identity (`HEADERS.User`) is derived from the ambient credential's
- * JWT `sub` claim by `credential-middleware`, not from the DB.
- */
-export function resolveAnalysisBilling(pool, analysisId) {
-    return tryQuery("analyses.resolveAnalysisBilling", () => pool.query({
-        text: "SELECT billing_context FROM cortex_analysis_state WHERE analysis_id = $1",
-        values: [analysisId],
-    })).map((result) => {
-        const row = result.rows[0];
-        if (!row) {
-            throw new Error(`resolveAnalysisBilling: no cortex_analysis_state row for analysisId=${analysisId}`);
-        }
-        const rawBilling = row.billing_context;
-        if (rawBilling === null || rawBilling === undefined) {
-            throw new Error(`resolveAnalysisBilling: billing_context missing for analysisId=${analysisId}`);
-        }
-        // JSONB is parsed by `pg` into native objects. Legacy TEXT rows (if any
-        // slipped through) arrive as strings — parse them.
-        let billingContext;
-        if (typeof rawBilling === "string") {
-            try {
-                billingContext = JSON.parse(rawBilling);
-            }
-            catch (err) {
-                throw new Error(`resolveAnalysisBilling: billing_context is not valid JSON for analysisId=${analysisId}: ${err instanceof Error ? err.message : err}`, { cause: err });
-            }
-        }
-        else {
-            billingContext = rawBilling;
-        }
-        return { billingContext };
-    });
-}

package/dist/state/index.d.ts

@@ -8,10 +8,10 @@
  */
 export { initCortexState } from "./init.js";
 export type { Querier } from "./db.js";
-export { upsertAnalysis, resolveAnalysisBilling, suspendAnalysis, resumeAnalysis, loadAnalysisStatus } from "./analyses.js";
+export { upsertAnalysis, suspendAnalysis, resumeAnalysis, loadAnalysisStatus } from "./analyses.js";
 export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifactPaths, queryUnsyncedStepArtifacts, updateArtifactId, updateFileIds, countArtifactsForRun, } from "./artifacts.js";
 export type { RegisterArtifactInput, InputArtifactMeta, StepArtifactRef } from "./artifacts.js";
-export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, markRunCanceledIfActive, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, queryRunsByThread, } from "./runs.js";
 export type { InsertRunInput, RunPage, RunReservation } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";

package/dist/state/index.js

@@ -7,9 +7,9 @@
  * specific entity module (e.g. `./state/runs.js`) when narrow.
  */
 export { initCortexState } from "./init.js";
-export { upsertAnalysis, resolveAnalysisBilling, suspendAnalysis, resumeAnalysis, loadAnalysisStatus } from "./analyses.js";
+export { upsertAnalysis, suspendAnalysis, resumeAnalysis, loadAnalysisStatus } from "./analyses.js";
 export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifactPaths, queryUnsyncedStepArtifacts, updateArtifactId, updateFileIds, countArtifactsForRun, } from "./artifacts.js";
-export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
+export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, markRunCanceledIfActive, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, queryRunsByThread, } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun } from "./step-executions.js";
 export { setSandboxRef, setActiveExecId, clearSandboxRef, queryActiveSandboxes, reconcileReapedSandbox } from "./active-sandboxes.js";

package/dist/state/init.js

@@ -12,7 +12,7 @@ import { createNoopLogger } from "../lib/console-logger.js";
 // splitting on ';' (see `DDL.split` below), so a semicolon inside a comment cuts
 // the statement it precedes in half and Postgres rejects the fragment.
 const DDL = `
--- Analysis-level state (status, context, data-profile tracking, billing identity).
+-- Analysis-level state (status, context, data-profile tracking).
 --
 -- User identity is derived from the ambient credential's JWT sub claim
 -- at request time — not persisted in this table.
@@ -20,7 +20,6 @@ CREATE TABLE IF NOT EXISTS cortex_analysis_state (
   analysis_id               TEXT PRIMARY KEY,
   status                    TEXT NOT NULL,
   context                   TEXT,
-  billing_context           JSONB,
   -- Nullable: NULL is the honest "no profile" state, which loadDataProfileStatus
   -- collapses to null so a cleared profile is indistinguishable from one that never
   -- existed. The 'pending' default still applies to a row inserted without a status --
@@ -491,6 +490,8 @@ export async function initCortexState(pool, injected) {
                 "ALTER TABLE cortex_analysis_state DROP COLUMN IF EXISTS profile",
                 "ALTER TABLE cortex_analysis_state DROP COLUMN IF EXISTS input_files",
                 "ALTER TABLE cortex_analysis_state DROP COLUMN IF EXISTS user_id",
+                // Billing identity is resolved lazily at charge-open time, never persisted.
+                "ALTER TABLE cortex_analysis_state DROP COLUMN IF EXISTS billing_context",
                 // v2 vestiges on cortex_runs.
                 "ALTER TABLE cortex_runs DROP COLUMN IF EXISTS plan",
                 "ALTER TABLE cortex_runs DROP COLUMN IF EXISTS plan_version",
@@ -523,7 +524,6 @@ export async function initCortexState(pool, injected) {
                 "ALTER TABLE cortex_runs ADD COLUMN IF NOT EXISTS synthesis_status TEXT",
                 "ALTER TABLE cortex_runs ADD COLUMN IF NOT EXISTS synthesis_reason TEXT",
                 "ALTER TABLE cortex_analysis_state ADD COLUMN IF NOT EXISTS data_profile_result JSONB",
-                "ALTER TABLE cortex_analysis_state ADD COLUMN IF NOT EXISTS billing_context JSONB",
                 // Sandbox reliability telemetry (from sandbox-reliability change on main).
                 "ALTER TABLE cortex_step_executions ADD COLUMN IF NOT EXISTS attempts INTEGER NOT NULL DEFAULT 1",
                 "ALTER TABLE cortex_step_executions ADD COLUMN IF NOT EXISTS last_error_class TEXT",

package/dist/state/runs.d.ts

@@ -83,6 +83,16 @@ export declare function queryActiveRun(pool: Querier, analysisId: string, planId
  */
 export declare function queryActiveRunsByAnalysis(pool: Querier, analysisId: string): ResultAsync<CortexRunRow[], DbError>;
 export declare function updateRunStatus(pool: Querier, runId: string, status: "running" | "completed" | "partial" | "failed" | "canceled" | "suspended_insufficient_funds", error?: string | null): ResultAsync<void, DbError>;
+/**
+ * Conditionally transition an ACTIVE run to `canceled`, stamping `completed_at`
+ * and recording `reason` in `error` (the same column `collectAndComplete`
+ * stamps `external_cancel` into). Reports whether a row transitioned — false
+ * means the run was already terminal (e.g. it completed concurrently with an
+ * external cancel), and the caller MUST NOT fall back to `updateRunStatus`,
+ * which would clobber that terminal status. The guarded set is the active set
+ * `queryActiveRun` deduplicates on.
+ */
+export declare function markRunCanceledIfActive(pool: Querier, runId: string, reason: string): ResultAsync<boolean, DbError>;
 export declare function promoteFailedToPartial(pool: Querier, runId: string): ResultAsync<boolean, DbError>;
 export declare function queryRun(pool: Querier, runId: string): ResultAsync<CortexRunRow | null, DbError>;
 export declare function queryRunsByAnalysis(pool: Querier, analysisId: string, { limit, offset }?: {

package/dist/state/runs.js

@@ -183,6 +183,27 @@ export function updateRunStatus(pool, runId, status, error) {
         });
     });
 }
+/**
+ * Conditionally transition an ACTIVE run to `canceled`, stamping `completed_at`
+ * and recording `reason` in `error` (the same column `collectAndComplete`
+ * stamps `external_cancel` into). Reports whether a row transitioned — false
+ * means the run was already terminal (e.g. it completed concurrently with an
+ * external cancel), and the caller MUST NOT fall back to `updateRunStatus`,
+ * which would clobber that terminal status. The guarded set is the active set
+ * `queryActiveRun` deduplicates on.
+ */
+export function markRunCanceledIfActive(pool, runId, reason) {
+    const now = new Date().toISOString();
+    return tryMutation("runs.markRunCanceledIfActive", async () => {
+        const result = await pool.query({
+            text: `UPDATE cortex_runs
+            SET status = 'canceled', completed_at = $2, error = $3
+            WHERE run_id = $1 AND status IN ('running','suspended_insufficient_funds')`,
+            values: [runId, now, reason],
+        });
+        return (result.rowCount ?? 0) > 0;
+    });
+}
 export function promoteFailedToPartial(pool, runId) {
     return tryMutation("runs.promoteFailedToPartial", async () => {
         const result = await pool.query({

package/dist/tasks/data-profile.d.ts

@@ -56,6 +56,13 @@ export interface DataProfileDeps extends EnvironmentStorePaths {
     readonly skillsDir: string;
     /** LLM usage-accounting seam for the profiler agent loop; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
+    /**
+     * Host-supplied labels for the profiler's sandbox pod, resolved under the
+     * profiling session. The map is opaque to the harness: it stamps each entry
+     * and interprets none of it. Absent in a wiring that attributes nothing —
+     * the pod then carries the harness's own labels only.
+     */
+    readonly resolvePodLabels?: (session: RunSession) => Promise<Record<string, string>>;
 }
 /**
  * Workflow input. JSON-serialisable — DBOS persists it as the workflow's

package/dist/tasks/data-profile.js

@@ -226,12 +226,26 @@ export async function runDataProfileBody(input, deps) {
         // from the agent loop would leave the longest wait of all unreported — the same defect the
         // run panel's activity readout was built to remove.
         await activity.sandboxInit();
+        let podLabels;
+        if (deps.resolvePodLabels) {
+            try {
+                podLabels = await deps.resolvePodLabels(childSession);
+            }
+            catch (err) {
+                logger.warn("pod-label resolution failed", logger.errorFields(err));
+            }
+            // A wired resolver that yields nothing is the one loud case: the host
+            // asked for attribution and the pod spawns without it.
+            if (!podLabels || Object.keys(podLabels).length === 0)
+                logger.warn("sandbox spawned with no pod labels");
+        }
         const sandbox = await deps.sandboxClient.createSandbox({
             runId: DATA_PROFILE_RUN_LITERAL,
             stepId: DATA_PROFILE_STEP_LITERAL,
             analysisId,
             childWorkflowId: workflowId,
             resources: estimateDataProfileResources(stagedInputs),
+            podLabels,
         }, mintSandboxIdentity(DATA_PROFILE_RUN_LITERAL));
         try {
             // Checkpointed clock, not `Date.now()`: `awaitExec` gates on this absolute

package/dist/tools/approval/gateway.d.ts

@@ -34,6 +34,13 @@ export interface AskGateway {
     ask(request: AskRequest, ctx: AskContext): Promise<AskApproval>;
     answer(id: string, reply: AskReply): Promise<AnswerOutcome>;
     pending(): Promise<PendingAsk[]>;
-    sweepExpired(): Promise<number>;
+    /** Expire pending asks older than `maxAgeMs` (default {@link DEFAULT_SWEEP_MAX_AGE_MS}). */
+    sweepExpired(maxAgeMs?: number): Promise<number>;
 }
+/**
+ * Pending rows older than this are treated as orphans of a dead process. Far
+ * beyond any plausible live turn, so a boot sweep during a rolling deployment
+ * cannot expire an ask another pod is still polling.
+ */
+export declare const DEFAULT_SWEEP_MAX_AGE_MS: number;
 export declare function createAskGateway(deps: AskGatewayDeps): AskGateway;

package/dist/tools/approval/gateway.js

@@ -15,6 +15,12 @@ import { answerAsk, insertGrantedAsk, insertPendingAsk, markAborted, selectAskRe
 import { uuidv7 } from "./uuidv7.js";
 /** Fixed poll cadence — imperceptible against human decision speed, low chatter. */
 const POLL_INTERVAL_MS = 200;
+/**
+ * Pending rows older than this are treated as orphans of a dead process. Far
+ * beyond any plausible live turn, so a boot sweep during a rolling deployment
+ * cannot expire an ask another pod is still polling.
+ */
+export const DEFAULT_SWEEP_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 export function createAskGateway(deps) {
     const { pool } = deps;
     async function ask(request, ctx) {
@@ -74,8 +80,9 @@ export function createAskGateway(deps) {
     async function pending() {
         return unwrapOrThrow(await selectPending(pool));
     }
-    async function sweepExpired() {
-        return unwrapOrThrow(await sweepExpiredRows(pool, new Date().toISOString()));
+    async function sweepExpired(maxAgeMs = DEFAULT_SWEEP_MAX_AGE_MS) {
+        const now = Date.now();
+        return unwrapOrThrow(await sweepExpiredRows(pool, new Date(now).toISOString(), new Date(now - maxAgeMs).toISOString()));
     }
     return { ask, answer, pending, sweepExpired };
 }

package/dist/tools/approval/queries.d.ts

@@ -63,8 +63,15 @@ export declare function selectAskResolution(querier: Querier, id: string): Resul
 export declare function markAborted(querier: Querier, id: string, resolvedAt: string): ResultAsync<void, DbError>;
 /** Enumerate every unresolved ask, oldest first. */
 export declare function selectPending(querier: Querier): ResultAsync<PendingAsk[], DbError>;
-/** Sweep every `pending` row to `expired`, returning the count swept. */
-export declare function sweepExpired(querier: Querier, expiredAt: string): ResultAsync<number, DbError>;
+/**
+ * Sweep `pending` rows created before `olderThan` to `expired`, returning the
+ * count swept. The age predicate is what keeps a boot sweep from expiring an ask
+ * another live pod is still polling — only rows old enough to be orphans of a
+ * dead process are touched. Both bounds compare as text: every `created_at` is a
+ * fixed-width UTC ISO string, so lexicographic order is chronological (the same
+ * property `selectPending`'s ORDER BY relies on).
+ */
+export declare function sweepExpired(querier: Querier, expiredAt: string, olderThan: string): ResultAsync<number, DbError>;
 /**
  * Record a decision against a still-`pending` row and, for an `always` reply,
  * write the standing grant — both in one transaction, so a crash between them can

package/dist/tools/approval/queries.js

@@ -100,12 +100,20 @@ export function selectPending(querier) {
         }));
     });
 }
-/** Sweep every `pending` row to `expired`, returning the count swept. */
-export function sweepExpired(querier, expiredAt) {
+/**
+ * Sweep `pending` rows created before `olderThan` to `expired`, returning the
+ * count swept. The age predicate is what keeps a boot sweep from expiring an ask
+ * another live pod is still polling — only rows old enough to be orphans of a
+ * dead process are touched. Both bounds compare as text: every `created_at` is a
+ * fixed-width UTC ISO string, so lexicographic order is chronological (the same
+ * property `selectPending`'s ORDER BY relies on).
+ */
+export function sweepExpired(querier, expiredAt, olderThan) {
     return tryMutation("asks.sweepExpired", async () => {
         const result = await querier.query({
-            text: `UPDATE cortex_asks SET status = 'expired', resolved_at = $1 WHERE status = 'pending'`,
-            values: [expiredAt],
+            text: `UPDATE cortex_asks SET status = 'expired', resolved_at = $1
+              WHERE status = 'pending' AND created_at < $2`,
+            values: [expiredAt, olderThan],
         });
         return result.rowCount ?? 0;
     });

package/dist/tools/report-session/index.d.ts

@@ -5,6 +5,6 @@
  * render seams, thus each tool binds the per-session state to the thread of the call. The barrel exports
  * the factories and their public types for the composition root.
  */
-export { createPreviewReportTool, type PreviewReportInput, type PreviewReportResult, type PreviewReportToolDeps } from "./preview-report.js";
+export { createPreviewReportTool, type PreviewReportInput, type PreviewReportResult, type PreviewReportToolDeps, type ResolvePageAsset, } from "./preview-report.js";
 export { createExaminePageTool, type CapturePage, type ExaminePageInput, type ExaminePageResult, type ExaminePageToolDeps, type FailedRequest, type PageCapture, } from "./examine-page.js";
 export { createRecordVersionTool, type RecordVersionInput, type RecordVersionResult, type RecordVersionToolDeps } from "./record-version.js";

package/dist/tools/report-session/index.js

@@ -5,6 +5,6 @@
  * render seams, thus each tool binds the per-session state to the thread of the call. The barrel exports
  * the factories and their public types for the composition root.
  */
-export { createPreviewReportTool } from "./preview-report.js";
+export { createPreviewReportTool, } from "./preview-report.js";
 export { createExaminePageTool, } from "./examine-page.js";
 export { createRecordVersionTool } from "./record-version.js";

package/dist/tools/report-session/preview-report.d.ts

@@ -6,7 +6,7 @@
  * resolves each reference through the injected resolver, bridges the resolved values into the render model,
  * and renders the page.
  *
- * The page and its staged image assets land in `report-sessions/{threadId}/` under the workspace root. That
+ * The page and its staged assets land in `report-sessions/{threadId}/` under the workspace root. That
  * namespace belongs to this path alone, thus the tool never writes under the old `previews/` or `reports/`
  * trees. The result carries the absolute page path, thus a local host shows the page with no seam.
  *
@@ -77,6 +77,11 @@ export type PreviewReportResult = {
     outcome: "rendered";
     pagePath: string;
 };
+/**
+ * The lookup of the source file of one staged asset. It maps the module specifier of a manifest entry
+ * (`report-render/assets.ts`) onto an absolute path on disk.
+ */
+export type ResolvePageAsset = (specifier: string) => string;
 /**
  * The construction deps of the preview tool.
  *
@@ -84,6 +89,10 @@ export type PreviewReportResult = {
  * serves every analysis and it resolves the root per call from the scope. `makeResolver` is optional, because
  * a resolver realization can be absent. It binds one analysis, thus the tool makes the resolver over the
  * scope of the call.
+ *
+ * `resolvePageAsset` is optional, and absent it resolves each specifier against the installation of the
+ * harness. An embedder that ships the asset bytes packed, for example a compiled single-file binary with no
+ * `node_modules` tree, materializes them to disk and binds its own lookup here.
  */
 export interface PreviewReportToolDeps {
     readonly gateway: ReportSessionStateGateway;
@@ -92,6 +101,7 @@ export interface PreviewReportToolDeps {
         auth: AuthContext;
     }) => ReferenceResolver;
     readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    readonly resolvePageAsset?: ResolvePageAsset;
     readonly logger?: Logger;
 }
 /**

package/dist/tools/report-session/preview-report.js

@@ -6,7 +6,7 @@
  * resolves each reference through the injected resolver, bridges the resolved values into the render model,
  * and renders the page.
  *
- * The page and its staged image assets land in `report-sessions/{threadId}/` under the workspace root. That
+ * The page and its staged assets land in `report-sessions/{threadId}/` under the workspace root. That
  * namespace belongs to this path alone, thus the tool never writes under the old `previews/` or `reports/`
  * trees. The result carries the absolute page path, thus a local host shows the page with no seam.
  *
@@ -26,6 +26,7 @@
  */
 import { err, ok } from "neverthrow";
 import { copyFile, mkdir, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { extname, join } from "node:path";
 import { z } from "zod";
 import { resolveWorkspacePath } from "../../workspace/paths.js";
@@ -36,6 +37,7 @@ import { computeDraftHash } from "../../report-model/draft-hash.js";
 import { finishDraft } from "../../report-model/draft-finish.js";
 import { resolveDocumentReferences } from "../../report-model/validate.js";
 import { bridgeValues } from "../../report-render/value-bridge.js";
+import { PAGE_ASSETS } from "../../report-render/assets.js";
 import { renderReportPage } from "../../report-render/render.js";
 import { defineTool } from "../define-tool.js";
 import { openReportThread } from "../report-authoring/authoring-tools.js";
@@ -56,6 +58,13 @@ function assetFileName(file) {
 function figureSourcePolicy(file) {
     return `assets/${assetFileName(file)}`;
 }
+/**
+ * The resolver of a package source. A manifest entry names a module specifier, and the resolution reads
+ * the installation of the harness. Thus the staged bytes are the bytes of the pinned version.
+ */
+const moduleResolver = createRequire(import.meta.url);
+/** The default asset lookup: the module resolution of the installation of the harness. */
+const resolvePageAssetFromInstallation = (specifier) => moduleResolver.resolve(specifier);
 /**
  * Pair each block with the resolved value of its binding, in document order.
  *
@@ -116,7 +125,7 @@ async function resolveDocument(document, resolver, snapshot) {
     return { resolutions: collectResolutions(document.sections, resolvedByBlock), unresolved: [] };
 }
 /**
- * Resolve the page root, stage each bound image, and write the page.
+ * Resolve the page root, stage each bound image and each manifest entry, and write the page.
  *
  * The workspace-root seam signals an unresolvable resource by a throw, thus the resolution sits inside
  * the protection and its throw becomes a value. Each `fs` call runs through `tryFsWrite`, the one
@@ -126,6 +135,10 @@ async function resolveDocument(document, resolver, snapshot) {
  * A bound figure names a snapshot path, which is untrusted. A registered `../../` path escapes the root,
  * thus the containment test runs before any copy and reuses the one workspace-path resolver. A source
  * outside the root refuses and names the block, and no copy runs.
+ *
+ * The page references the chart runtime and the fonts under the same `assets/` directory, thus one copy
+ * loop stages the figures and the manifest entries together. The manifest is never empty, thus the assets
+ * directory exists beside every page.
  */
 async function renderToWorkspace(args) {
     let root;
@@ -155,20 +168,28 @@ async function renderToWorkspace(args) {
         }
         sources.set(name, resolved.absolute);
     }
+    // Each manifest entry, mapped from its staged name to the file that the asset lookup gives. A specifier
+    // that does not resolve is a fault of the installation, thus it rides the `fs` kind.
+    for (const asset of PAGE_ASSETS) {
+        try {
+            sources.set(asset.file, args.resolvePageAsset(asset.specifier));
+        }
+        catch (cause) {
+            return err({ kind: "fs", error: { type: "read_failed", op: "preview.resolveAsset", path: asset.specifier, cause } });
+        }
+    }
     const madeSession = await tryFsWrite("preview.mkdir", () => mkdir(sessionDir, { recursive: true }), { path: sessionDir });
     if (madeSession.isErr()) {
         return err({ kind: "fs", error: madeSession.error });
     }
-    if (sources.size > 0) {
-        const madeAssets = await tryFsWrite("preview.mkdir", () => mkdir(assetsDir, { recursive: true }), { path: assetsDir });
-        if (madeAssets.isErr()) {
-            return err({ kind: "fs", error: madeAssets.error });
-        }
-        for (const [name, source] of sources) {
-            const copied = await tryFsWrite("preview.copyFile", () => copyFile(source, join(assetsDir, name)), { path: source });
-            if (copied.isErr()) {
-                return err({ kind: "fs", error: copied.error });
-            }
+    const madeAssets = await tryFsWrite("preview.mkdir", () => mkdir(assetsDir, { recursive: true }), { path: assetsDir });
+    if (madeAssets.isErr()) {
+        return err({ kind: "fs", error: madeAssets.error });
+    }
+    for (const [name, source] of sources) {
+        const copied = await tryFsWrite("preview.copyFile", () => copyFile(source, join(assetsDir, name)), { path: source });
+        if (copied.isErr()) {
+            return err({ kind: "fs", error: copied.error });
         }
     }
     const wrote = await tryFsWrite("preview.writeFile", () => writeFile(pagePath, args.page, "utf8"), { path: pagePath });
@@ -186,6 +207,7 @@ async function renderToWorkspace(args) {
  */
 export function createPreviewReportTool(deps) {
     const logger = (deps.logger ?? createNoopLogger()).named("preview-report");
+    const resolvePageAsset = deps.resolvePageAsset ?? resolvePageAssetFromInstallation;
     return defineTool({
         id: "preview_report",
         description: "Render the current draft to a self-contained HTML page, and give back the page path. " +
@@ -235,6 +257,7 @@ export function createPreviewReportTool(deps) {
             }
             const written = await renderToWorkspace({
                 resolveWorkspaceRoot: deps.resolveWorkspaceRoot,
+                resolvePageAsset,
                 analysisId,
                 threadId,
                 resolutions,

package/dist/workflows/sandbox-step.d.ts

@@ -232,6 +232,13 @@ export interface SandboxStepDeps {
     /** Write-side embedder for the post-step vector index. */
     readonly embedding: EmbeddingProvider;
     readonly sandboxClient: SandboxClient;
+    /**
+     * Host-supplied labels for this step's sandbox pod, resolved under the
+     * step's session. The map is opaque to the harness: it stamps each entry
+     * and interprets none of it. Absent in a wiring that attributes nothing —
+     * the pod then carries the harness's own labels only.
+     */
+    readonly resolvePodLabels?: (session: RunSession) => Promise<Record<string, string>>;
     /**
      * External artifact registration + sync seam. The harness's post-step pipeline
      * registers each step's outputs through it (filesystem index in the

package/dist/workflows/sandbox-step.js

@@ -151,7 +151,9 @@ export async function runSandboxStepBody(input, deps) {
     const identity = await DBOS.runStep(() => Promise.resolve(mintSandboxIdentity(input.runId)), { name: "sandbox.mint" });
     // (2b) sandbox.create — spawn (or adopt) the machine under the minted
     // identity. The handle (secret included) is cached so recovery picks the
-    // same machine back up without re-provisioning.
+    // same machine back up without re-provisioning. Pod-label resolution lives
+    // INSIDE this step (not as its own step) so the child's step sequence is
+    // unchanged — in-flight workflows resumed across a deploy replay cleanly.
     const sandboxMeta = {
         runId: input.runId,
         stepId: input.stepId,
@@ -161,7 +163,22 @@ export async function runSandboxStepBody(input, deps) {
         extraEnv: input.extraEnv,
         resources: input.resources,
     };
-    const sandbox = await DBOS.runStep(() => deps.sandboxClient.createSandbox(sandboxMeta, identity), { name: "sandbox.create" });
+    const sandbox = await DBOS.runStep(async () => {
+        let podLabels;
+        if (deps.resolvePodLabels) {
+            try {
+                podLabels = await deps.resolvePodLabels(session);
+            }
+            catch (err) {
+                logger.warn("pod-label resolution failed", { analysisId: input.analysisId, ...logger.errorFields(err) });
+            }
+            // A wired resolver that yields nothing is the one loud case: the
+            // host asked for attribution and the pod spawns without it.
+            if (!podLabels || Object.keys(podLabels).length === 0)
+                logger.warn("sandbox spawned with no pod labels", { analysisId: input.analysisId });
+        }
+        return deps.sandboxClient.createSandbox({ ...sandboxMeta, podLabels }, identity);
+    }, { name: "sandbox.create" });
     // Recovery path: re-check `isAlive` on the persisted ref before continuing.
     // A classified-dead sandbox triggers a fresh `createSandbox` (task 4.6).
     // For first execution this is a cheap no-op; on replay it's the seam

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.19.1",
+    "version": "0.20.0",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -34,6 +34,7 @@
     },
     "scripts": {
         "build": "tsc -p tsconfig.json",
+        "design:fixture": "bun scripts/render-fixture.ts",
         "format": "prettier --write src/",
         "format:file": "prettier --write",
         "lint": "eslint .",
@@ -51,6 +52,8 @@
         "@ai-sdk/provider-utils": "5.0.27",
         "@anthropic-ai/sdk": "^0.116.0",
         "@dbos-inc/dbos-sdk": "^4.23.6",
+        "@fontsource-variable/space-grotesk": "5.1.1",
+        "@fontsource/ibm-plex-mono": "5.1.1",
         "@kubernetes/client-node": "^1.4.0",
         "@opentelemetry/api": "^1.9.1",
         "@opentelemetry/core": "^2.9.0",
@@ -64,6 +67,7 @@
         "ai": "^7.0.61",
         "cheerio": "^1.2.0",
         "dockerode": "^4.0.12",
+        "echarts": "5.5.1",
         "fast-xml-parser": "^5.10.0",
         "hono": "^4.12.30",
         "hyparquet": "^1.28.1",