@inflexa-ai/harness 0.1.1 → 0.3.0

package/dist/reference-data/receipt.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { ReferenceArtifactPathSchema, ReferenceDatasetSchema, ReferenceSha256Schema } from "./catalog.js";
+/** Schema version for installation receipts shared by all embedders. */
+export const REFERENCE_INSTALL_RECEIPT_VERSION = 1;
+/**
+ * What was actually written to disk for one artifact. The size and digest are
+ * *observed at install*, never copied from the catalog — for a `pinned`
+ * artifact they equal the catalog's (the install would have failed otherwise),
+ * and for an `unpinned` one they are the only record of what the mutable
+ * upstream served, which is what `verify` later checks the files against.
+ */
+const ReferenceReceiptArtifactSchema = z.object({
+    path: ReferenceArtifactPathSchema,
+    bytes: z.number().int().nonnegative(),
+    sha256: ReferenceSha256Schema,
+    integrity: z.enum(["pinned", "unpinned"]),
+});
+/** Optional metadata describing one activated reference dataset version. */
+export const ReferenceInstallReceiptSchema = z
+    .object({
+    version: z.literal(REFERENCE_INSTALL_RECEIPT_VERSION),
+    datasetId: ReferenceDatasetSchema.shape.id,
+    datasetVersion: ReferenceDatasetSchema.shape.version,
+    activatedAt: z.iso.datetime({ offset: true }),
+    artifacts: z.array(ReferenceReceiptArtifactSchema).min(1),
+})
+    .superRefine((receipt, ctx) => {
+    const paths = new Set();
+    for (const [index, artifact] of receipt.artifacts.entries()) {
+        if (paths.has(artifact.path)) {
+            ctx.addIssue({ code: "custom", message: `Duplicate receipt artifact path: ${artifact.path}`, path: ["artifacts", index, "path"] });
+        }
+        paths.add(artifact.path);
+    }
+});
+/** Parse optional/untrusted receipt metadata; invalid receipts are ignored. */
+export function parseReferenceInstallReceipt(input) {
+    const result = ReferenceInstallReceiptSchema.safeParse(input);
+    return result.success ? result.data : undefined;
+}

package/dist/runtime/boot.d.ts

@@ -31,7 +31,7 @@
  * once shutdown starts, exiting takes precedence (see `runShutdownSequence`).
  */
 import type { Pool } from "pg";
-import type pino from "pino";
+import type { Logger } from "../lib/logger.js";
 import { type CoreRuntime, type CoreRuntimeDeps } from "./assemble.js";
 import { type ConnectionBudgetConfig } from "./connection-budget.js";
 import { type DbosConfig } from "./dbos.js";
@@ -46,7 +46,7 @@ export interface BootHarnessDeps {
     readonly dbos: DbosConfig;
     /** Connection-budget guard config. */
     readonly connectionBudget: ConnectionBudgetConfig;
-    readonly logger: pino.Logger;
+    readonly logger: Logger;
     /**
      * Host-specific work that must run AFTER workflow registration and BEFORE
      * DBOS launch (scheduled sweeps, ephemeral reap, agent-switch install). The

package/dist/runtime/boot.js

@@ -49,7 +49,7 @@ export async function bootHarness(deps) {
     const runtime = assembleCoreRuntime(core);
     await deps.beforeLaunch?.();
     await launchDbos({ config: deps.dbos, logger });
-    logger.info({ executorId: deps.dbos.executorId }, "[boot] harness booted");
+    logger.named("boot").info("harness booted", { executorId: deps.dbos.executorId });
     const shutdown = (signal) => runShutdownSequence({
         signal,
         logger,

package/dist/runtime/connection-budget.d.ts

@@ -21,7 +21,7 @@
  * misconfigured pod fails boot loudly instead of degrading under load.
  */
 import type { Pool } from "pg";
-import type pino from "pino";
+import type { Logger } from "../lib/logger.js";
 /**
  * Narrow config slice the budget guard reads — only the optional app-pool
  * size override. Composition roots map `Env.DB_POOL_MAX` onto this.
@@ -31,7 +31,7 @@ export interface ConnectionBudgetConfig {
 }
 export interface AssertConnectionBudgetOptions {
     pool: Pool;
-    logger: pino.Logger;
+    logger: Logger;
     config: ConnectionBudgetConfig;
 }
 /**

package/dist/runtime/connection-budget.js

@@ -38,15 +38,17 @@ export async function assertConnectionBudget({ pool, logger, config }) {
             `Lower DB_POOL_MAX or raise max_connections.`);
     }
     const supportedReplicas = Math.floor((maxConnections - SAFETY_MARGIN) / podFootprint);
-    logger.info({
+    logger
+        .named("boot")
+        .info(`postgres connection budget OK — this cluster's max_connections ` +
+        `supports ~${supportedReplicas} cortex replicas; size replicas/pooler accordingly`, {
         maxConnections,
         appPoolSize,
         dbosPoolSize,
         podFootprint,
         safetyMargin: SAFETY_MARGIN,
         supportedReplicas,
-    }, `[boot] postgres connection budget OK — this cluster's max_connections ` +
-        `supports ~${supportedReplicas} cortex replicas; size replicas/pooler accordingly`);
+    });
     return {
         maxConnections,
         appPoolSize,

package/dist/runtime/dbos.d.ts

@@ -12,8 +12,8 @@
  *
  * See `openspec/changes/harness-dbos-runtime`.
  */
-import type pino from "pino";
 import type { Pool } from "pg";
+import type { Logger } from "../lib/logger.js";
 /**
  * Narrow config slice the DBOS bootstrap reads. Composition roots map their
  * validated `Env` onto this and pass the executor id in (the harness reads no env).
@@ -50,9 +50,9 @@ interface State {
  * must resolve before the HTTP listener accepts traffic (otherwise the
  * readiness probe could 200 against a runtime that can't own workflows).
  */
-export declare function launchDbos({ config, logger }: {
+export declare function launchDbos({ config, logger: injected }: {
     config: DbosConfig;
-    logger: pino.Logger;
+    logger: Logger;
 }): Promise<void>;
 /**
  * Shut DBOS down. In-flight workflows are marked recoverable so another
@@ -63,8 +63,8 @@ export declare function launchDbos({ config, logger }: {
  * Must run after HTTP has drained (so no inbound request is orphaned) and
  * before the application pool closes (DBOS needs the system DB).
  */
-export declare function shutdownDbos({ logger }: {
-    logger: pino.Logger;
+export declare function shutdownDbos({ logger: injected }: {
+    logger: Logger;
 }): Promise<void>;
 /**
  * Cancel any `ephemeral:`-prefixed PENDING workflow this executor owns —
@@ -79,9 +79,9 @@ export declare function shutdownDbos({ logger }: {
  * pre-launch timing, and this is the sole module that owns DBOS. The system
  * DB is the same database as the app pool, so the pool reaches it directly.
  */
-export declare function sweepEphemeralWorkflows({ pool, logger, executorId, }: {
+export declare function sweepEphemeralWorkflows({ pool, logger: injectedLogger, executorId, }: {
     pool: Pool;
-    logger: pino.Logger;
+    logger: Logger;
     /** Stable per-pod executor id — must match `launchDbos`'s `executorId`. */
     executorId: string;
 }): Promise<void>;

package/dist/runtime/dbos.js

@@ -53,9 +53,10 @@ function systemDatabaseUrl(config) {
  * must resolve before the HTTP listener accepts traffic (otherwise the
  * readiness probe could 200 against a runtime that can't own workflows).
  */
-export async function launchDbos({ config, logger }) {
+export async function launchDbos({ config, logger: injected }) {
     if (state.launched)
         return;
+    const logger = injected.named("dbos");
     const executorID = config.executorId;
     const adminPort = parseInt(config.adminPort, 10);
     DBOS.setConfig({
@@ -71,12 +72,12 @@ export async function launchDbos({ config, logger }) {
     await DBOS.launch();
     state.launched = true;
     state.recoveryStarted = true;
-    logger.info({
+    logger.info("launched", {
         executorID,
         applicationVersion: config.applicationVersion,
         adminPort,
         durationMs: Math.round(performance.now() - start),
-    }, "[dbos] launched");
+    });
 }
 /**
  * Shut DBOS down. In-flight workflows are marked recoverable so another
@@ -87,19 +88,20 @@ export async function launchDbos({ config, logger }) {
  * Must run after HTTP has drained (so no inbound request is orphaned) and
  * before the application pool closes (DBOS needs the system DB).
  */
-export async function shutdownDbos({ logger }) {
+export async function shutdownDbos({ logger: injected }) {
     if (!state.launched)
         return;
+    const logger = injected.named("dbos");
     const start = performance.now();
     try {
         await DBOS.shutdown();
-        logger.info({ durationMs: Math.round(performance.now() - start) }, "[dbos] shutdown");
+        logger.info("shutdown", { durationMs: Math.round(performance.now() - start) });
     }
     catch (err) {
-        logger.error({
-            err: err instanceof Error ? err.message : String(err),
+        logger.error("shutdown failed", {
+            ...logger.errorFields(err),
             durationMs: Math.round(performance.now() - start),
-        }, "[dbos] shutdown failed");
+        });
     }
     finally {
         state.launched = false;
@@ -119,7 +121,8 @@ export async function shutdownDbos({ logger }) {
  * pre-launch timing, and this is the sole module that owns DBOS. The system
  * DB is the same database as the app pool, so the pool reaches it directly.
  */
-export async function sweepEphemeralWorkflows({ pool, logger, executorId, }) {
+export async function sweepEphemeralWorkflows({ pool, logger: injectedLogger, executorId, }) {
+    const logger = injectedLogger.named("dbos");
     const executorID = executorId;
     try {
         const { rowCount } = await pool.query({
@@ -131,7 +134,7 @@ export async function sweepEphemeralWorkflows({ pool, logger, executorId, }) {
             values: [Date.now(), executorID],
         });
         if (rowCount && rowCount > 0) {
-            logger.info({ executorID, swept: rowCount }, "[dbos] swept orphaned ephemeral workflows");
+            logger.info("swept orphaned ephemeral workflows", { executorID, swept: rowCount });
         }
     }
     catch (err) {
@@ -139,7 +142,7 @@ export async function sweepEphemeralWorkflows({ pool, logger, executorId, }) {
         if (err && typeof err === "object" && "code" in err && err.code === "42P01") {
             return;
         }
-        logger.error({ executorID, err: err instanceof Error ? err.message : String(err) }, "[dbos] ephemeral sweep failed");
+        logger.error("ephemeral sweep failed", { executorID, ...logger.errorFields(err) });
     }
 }
 /** Snapshot of DBOS lifecycle state — read by the readiness probe. */

package/dist/runtime/shutdown.d.ts

@@ -18,10 +18,10 @@
  * swallowed — once shutdown has started, exiting takes precedence over
  * any single step's failure.
  */
-import type pino from "pino";
+import type { Logger } from "../lib/logger.js";
 export interface ShutdownDeps {
     signal: string;
-    logger: pino.Logger;
+    logger: Logger;
     markDraining: () => void;
     closeHttpServer: () => Promise<void>;
     shutdownDbos: () => Promise<void>;

package/dist/runtime/shutdown.js

@@ -23,12 +23,13 @@ async function safely(logger, step, fn) {
         await fn();
     }
     catch (err) {
-        logger.error({ err: err instanceof Error ? err.message : String(err), step }, `[shutdown] ${step} failed`);
+        logger.error(`${step} failed`, { ...logger.errorFields(err), step });
     }
 }
 export async function runShutdownSequence(deps) {
-    const { logger, signal } = deps;
-    logger.info({ signal }, "[shutdown] requested");
+    const { signal } = deps;
+    const logger = deps.logger.named("shutdown");
+    logger.info("requested", { signal });
     deps.markDraining();
     await safely(logger, "http-drain", deps.closeHttpServer);
     await safely(logger, "dbos-shutdown", deps.shutdownDbos);

package/dist/sandbox/create-sandbox.d.ts

@@ -13,7 +13,7 @@
  */
 import type { V1Toleration } from "@kubernetes/client-node";
 import type { Pool } from "pg";
-import type pino from "pino";
+import type { Logger } from "../lib/logger.js";
 import { type ResourceLimits } from "../config/resource-limits.js";
 import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { clearSandboxRef } from "../state/index.js";
@@ -87,7 +87,7 @@ export interface CreateSandboxClientConfig {
      * (a configured store whose `current` vanished/went incomplete mid-session) is
      * observable rather than a silent mount drop. No-op when unset.
      */
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
     /** Dependency seams (fetch, durable step/sleep, clock, recv, warn sink) forwarded to submit/await. */
     submitDeps?: SubmitExecDeps;
     awaitOptions?: AwaitExecOptions;

package/dist/sandbox/docker-client.d.ts

@@ -29,8 +29,8 @@
  * effective capabilities.
  */
 import Docker from "dockerode";
-import type pino from "pino";
 import { ResultAsync } from "neverthrow";
+import type { Logger } from "../lib/logger.js";
 import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type SandboxError } from "./sandbox-error.js";
 import type { CreateSandboxMeta, ManagedSandbox, SandboxIdentity, SandboxLiveness, SandboxRef, SandboxTransport } from "./types.js";
@@ -62,7 +62,7 @@ export interface DockerClientConfig {
      * vanished or went incomplete by sandbox-create time) is observable instead of a
      * silent libs-mount drop. Matches the `reaper`/`watchdog` logger seam.
      */
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
     /** Hook called after the registry row is written. */
     registerSandbox: (meta: CreateSandboxMeta, ref: SandboxRef) => Promise<void>;
 }

package/dist/sandbox/docker-client.js

@@ -32,6 +32,7 @@ import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import Docker from "dockerode";
 import { ResultAsync, err, ok } from "neverthrow";
+import { createNoopLogger } from "../lib/console-logger.js";
 import { stepWritePrefix } from "../workspace/paths.js";
 import { trySandbox } from "./sandbox-error.js";
 import { buildMountPlan } from "./mount-plan.js";
@@ -158,7 +159,9 @@ export function createDockerSandboxOps(config) {
                 // since an otherwise-silent libs-mount drop is invisible to operators.
                 const libsMounted = !!config.libStorePath && libStoreUsable(config.libStorePath);
                 if (config.libStorePath && !libsMounted) {
-                    config.logger?.warn({ libStorePath: config.libStorePath, sandboxId }, "[docker-client] lib store configured but `current` is missing or incomplete at sandbox creation — mounting no library store (sandbox degrades to available:false)");
+                    (config.logger ?? createNoopLogger())
+                        .named("docker-client")
+                        .warn("lib store configured but `current` is missing or incomplete at sandbox creation — mounting no library store (sandbox degrades to available:false)", { libStorePath: config.libStorePath, sandboxId });
                 }
                 const plan = buildMountPlan(meta, {
                     libs: libsMounted,

package/dist/sandbox/k8s-client.d.ts

@@ -16,6 +16,7 @@ import { ResultAsync } from "neverthrow";
 import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
 import { type SandboxError } from "./sandbox-error.js";
 import type { CreateSandboxMeta, ManagedSandbox, SandboxIdentity, SandboxLiveness, SandboxRef, SandboxTransport } from "./types.js";
+import type { Logger } from "../lib/logger.js";
 /**
  * Coerce an arbitrary identifier into a valid K8s label value:
  * ≤63 chars, `[A-Za-z0-9._-]` only, starting and ending alphanumeric.
@@ -27,6 +28,8 @@ import type { CreateSandboxMeta, ManagedSandbox, SandboxIdentity, SandboxLivenes
  */
 export declare function sanitizeLabelValue(value: string): string;
 export interface K8sClientConfig {
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
     image: string;
     cortexBaseUrl: string;
     /**

package/dist/sandbox/k8s-client.js

@@ -16,6 +16,7 @@ import { BatchV1Api, CoreV1Api, KubeConfig } from "@kubernetes/client-node";
 import { ResultAsync, err, ok } from "neverthrow";
 import { trySandbox } from "./sandbox-error.js";
 import { buildMountPlan, buildSessionSubPaths } from "./mount-plan.js";
+import { createNoopLogger } from "../lib/console-logger.js";
 /** Read the originating HTTP status off any `SandboxError` variant that carries one. */
 function statusOf(e) {
     return "status" in e ? e.status : undefined;
@@ -410,12 +411,12 @@ export function createK8sSandboxOps(config) {
                         cause,
                     }));
                     if (registered.isErr()) {
-                        await cleanupFailedJob(batchApi, config.namespace, sandboxId);
+                        await cleanupFailedJob(batchApi, config.namespace, sandboxId, config.logger ?? createNoopLogger());
                         return err(registered.error);
                     }
                     return ok(ref);
                 }
-                await cleanupFailedJob(batchApi, config.namespace, sandboxId);
+                await cleanupFailedJob(batchApi, config.namespace, sandboxId, config.logger ?? createNoopLogger());
                 return err(ready.error);
             })());
         },
@@ -480,9 +481,9 @@ export function createK8sSandboxOps(config) {
  * matters; a delete error here is logged and swallowed so it never masks the
  * create error returned to the caller.
  */
-async function cleanupFailedJob(batchApi, namespace, sandboxId) {
+async function cleanupFailedJob(batchApi, namespace, sandboxId, logger) {
     const deleted = await deleteJobIgnoreMissing(batchApi, namespace, sandboxId);
     if (deleted.isErr()) {
-        console.error(`K8sSandbox: failed to delete Job ${sandboxId} after startup failure`, deleted.error);
+        logger.named("k8s-client").error("failed to delete Job after startup failure", { sandboxId, err: deleted.error });
     }
 }

package/dist/sandbox/notification-sweep.d.ts

@@ -17,14 +17,14 @@
  * injectable so tests can drive the sweep against a stub.
  */
 import type { Pool } from "pg";
-import type pino from "pino";
+import type { Logger } from "../lib/logger.js";
 export interface SweepDeps {
     /**
      * Execute the bounded DELETE. Returns the row count cleared. Injected
      * for tests; production wires the app pool.
      */
     deleteStale: (limit: number) => Promise<number>;
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
 }
 export declare function sweepStaleNotifications(deps: SweepDeps): Promise<number>;
 /**
@@ -35,7 +35,7 @@ export declare function sweepStaleNotifications(deps: SweepDeps): Promise<number
 export declare function makeDefaultDeleteStale(pool: Pool): (limit: number) => Promise<number>;
 export interface RegisterNotificationSweepDeps {
     pool: Pool;
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
     /** Override the DELETE driver — production defaults to the app pool. */
     deleteStale?: (limit: number) => Promise<number>;
 }

package/dist/sandbox/notification-sweep.js

@@ -17,16 +17,18 @@
  * injectable so tests can drive the sweep against a stub.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { createNoopLogger } from "../lib/console-logger.js";
 const SWEEP_CRON = "0 */5 * * * *";
 const DELETE_BATCH_LIMIT = 10_000;
 export async function sweepStaleNotifications(deps) {
+    const logger = (deps.logger ?? createNoopLogger()).named("notification-sweep");
     try {
         const cleared = await deps.deleteStale(DELETE_BATCH_LIMIT);
-        deps.logger?.info({ rowsCleared: cleared }, "[notification-sweep] cleared stale notifications");
+        logger.info("cleared stale notifications", { rowsCleared: cleared });
         return cleared;
     }
     catch (err) {
-        deps.logger?.error({ err: err instanceof Error ? err.message : String(err) }, "[notification-sweep] sweep failed");
+        logger.error("sweep failed", logger.errorFields(err));
         throw err;
     }
 }

package/dist/sandbox/reaper.d.ts

@@ -18,8 +18,8 @@
  * hoisted for unit testing without a DBOS runtime; `registerSandboxReaper` is
  * the thin production wiring.
  */
-import type pino from "pino";
 import type { Pool } from "pg";
+import type { Logger } from "../lib/logger.js";
 import type { SandboxClient } from "./client.js";
 import type { ManagedSandbox } from "./types.js";
 export type ReapDecision = "leave" | "reap";
@@ -46,7 +46,7 @@ export interface ReaperDeps {
     graceMs?: number;
     /** Wall-clock ms; injected for tests. */
     nowMs?: () => number;
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
 }
 export interface ReapSummary {
     managedCount: number;
@@ -64,7 +64,7 @@ export interface RegisterReaperDeps {
     pool: Pool;
     sandboxClient: Pick<SandboxClient, "listManagedSandboxes" | "teardownById">;
     graceMs?: number;
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
 }
 /** Production registration: a single (unsharded) `@DBOS.scheduled` workflow. */
 export declare function registerSandboxReaper(deps: RegisterReaperDeps): void;

package/dist/sandbox/reaper.js

@@ -19,6 +19,7 @@
  * the thin production wiring.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { reconcileReapedSandbox } from "../state/active-sandboxes.js";
 const REAPER_CRON = "0 */5 * * * *";
@@ -65,6 +66,7 @@ export function terminalStepStatus(workflowStatus) {
  * failure on one machine is logged and skipped — the next sweep retries.
  */
 export async function reapOnce(deps) {
+    const logger = (deps.logger ?? createNoopLogger()).named("sandbox-reaper");
     const nowMs = (deps.nowMs ?? (() => Date.now()))();
     const graceMs = deps.graceMs ?? DEFAULT_GRACE_MS;
     const managed = await deps.sandboxClient.listManagedSandboxes();
@@ -85,10 +87,10 @@ export async function reapOnce(deps) {
                 rowsReconciled++;
         }
         catch (err) {
-            deps.logger?.warn({
+            logger.warn("reap failed — skipping this round", {
                 sandboxId: sb.sandboxId,
-                err: err instanceof Error ? err.message : String(err),
-            }, "[sandbox-reaper] reap failed — skipping this round");
+                ...logger.errorFields(err),
+            });
         }
     }
     const summary = {
@@ -97,7 +99,8 @@ export async function reapOnce(deps) {
         rowsReconciled,
         leftCount,
     };
-    deps.logger?.info(summary, "[sandbox-reaper] sweep completed");
+    // Spread: an interface has no implicit index signature, so it needs widening to `LogFields`.
+    logger.info("sweep completed", { ...summary });
     return summary;
 }
 /** Production registration: a single (unsharded) `@DBOS.scheduled` workflow. */

package/dist/sandbox/watchdog.d.ts

@@ -18,8 +18,8 @@
  * without spinning a DBOS runtime; `registerWatchdog` is the thin
  * production wiring.
  */
-import type pino from "pino";
 import type { ResultAsync } from "neverthrow";
+import type { Logger } from "../lib/logger.js";
 import type { DbError } from "../lib/db-result.js";
 import type { ActiveSandboxRow } from "../state/index.js";
 import type { SandboxClient } from "./client.js";
@@ -39,7 +39,7 @@ export interface CheckShardDeps {
      * this is `DBOS.send`; injected here for testability.
      */
     sendSynthetic: (workflowId: string, execId: string, failure: ExecResult, reason: string) => Promise<void>;
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
 }
 export interface CheckShardSummary {
     activeCount: number;
@@ -61,7 +61,7 @@ export interface WatchdogDeps {
     queryActiveSandboxes: () => ResultAsync<ActiveSandboxRow[], DbError>;
     sandboxClient: SandboxClient;
     shardCount?: number;
-    logger?: Pick<pino.Logger, "info" | "warn" | "error">;
+    logger?: Logger;
 }
 /**
  * Production registration. Builds the parent + child registered workflows

package/dist/sandbox/watchdog.js

@@ -20,6 +20,7 @@
  */
 import { createHash } from "node:crypto";
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { workflowIdFromExec } from "./exec-id.js";
 import { syntheticFailureReason, syntheticFailureResult } from "./liveness.js";
@@ -48,6 +49,7 @@ const ACTIVE_WORKFLOW_STATUSES = new Set(["PENDING", "ENQUEUED"]);
  * notification.
  */
 export async function checkShard(rows, deps) {
+    const logger = (deps.logger ?? createNoopLogger()).named("sandbox-watchdog");
     let deadCount = 0;
     let syntheticSends = 0;
     let liveWorkflowsSkipped = 0;
@@ -64,7 +66,10 @@ export async function checkShard(rows, deps) {
             liveness = await deps.isAlive(ref);
         }
         catch (err) {
-            deps.logger?.warn({ sandboxId: row.sandboxRef.sandboxId, err: err instanceof Error ? err.message : String(err) }, "[sandbox-watchdog] isAlive threw — skipping this round");
+            logger.warn("isAlive threw — skipping this round", {
+                sandboxId: row.sandboxRef.sandboxId,
+                ...logger.errorFields(err),
+            });
             continue;
         }
         if (liveness.alive)
@@ -92,7 +97,8 @@ export async function checkShard(rows, deps) {
         syntheticSends,
         liveWorkflowsSkipped,
     };
-    deps.logger?.info(summary, "[sandbox-watchdog] shard check completed");
+    // Spread: an interface has no implicit index signature, so it needs widening to `LogFields`.
+    logger.info("shard check completed", { ...summary });
     return summary;
 }
 /** Encodes the synthetic-failure marker on the per-exec topic envelope. */

package/dist/schemas/data-profile-schemas.js

@@ -15,7 +15,7 @@ export const ProfilerFileSchema = z.object({
         .describe("Semantic data type: count-matrix, normalized-expression, variants, alignments, " +
         "clinical-metadata, clinical-sdtm, clinical-adam, clinical-response, " +
         "pharmacokinetic-data, adverse-events, safety-labs, " +
-        "molecular-structures, annotations"),
+        "molecular-structures, annotations, document (paper PDF, README, methods doc)"),
     format: z.string().describe("File format (e.g. CSV, TSV, h5ad, MTX, VCF, BAM, SDF, FASTQ)"),
     rows: z.number().nullish(),
     cols: z.number().nullish(),
@@ -43,7 +43,7 @@ export const OrganismSchema = z.object({
     source: SubjectSourceEnum,
     confidence: z
         .enum(["high", "medium", "low"])
-        .describe("high: explicit organism column or paper/README statement. " +
+        .describe("high: explicit user-context statement, an organism column, or a paper/README statement. " +
         "medium: filename convention or accession lookup. " +
         "low: inferred from gene IDs or other indirect signals, OR sources disagree (in which case also record the conflict in qualityAssessment.concerns)."),
     notes: z.string().optional().describe("Brief note when source is 'inferred' or confidence is 'low' (one sentence)."),
@@ -51,7 +51,9 @@ export const OrganismSchema = z.object({
 export const ProfilerOutputSchema = z.object({
     files: z.array(ProfilerFileSchema),
     analysisSummary: z.string().describe("Narrative overview of the dataset — structure, content, analytical potential, and limitations"),
-    domain: z.string().describe("Scientific domain (e.g. transcriptomics, proteomics, genomics, chemistry, clinical, imaging, metabolomics, multi-omics)"),
+    domain: z
+        .string()
+        .describe("Scientific domain (e.g. transcriptomics, proteomics, genomics, cheminformatics, clinical, imaging, metabolomics, multi-omics)"),
     subtype: z.string().optional().describe("Specific subtype within domain (e.g. bulk-rna-seq, single-cell, LC-MS/MS, whole-genome-sequencing)"),
     organism: OrganismSchema.nullable().describe("Subject organism, identified from any input (metadata files, paper PDFs, READMEs, filenames, accession patterns). " +
         "Set to null ONLY when no input identifies the organism — never guess. " +