@inflexa-ai/harness 0.2.0 → 0.4.0

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

@@ -13,14 +13,14 @@
  */
 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";
 import { type AwaitExecOptions } from "./await-exec.js";
 import type { SandboxClient } from "./client.js";
 import { type SubmitExecDeps } from "./submit-exec.js";
-import { type SandboxTransport } from "./types.js";
+import { type CreateSandboxMeta, type SandboxTransport } from "./types.js";
 /**
  * Narrow config slice the sandbox factory reads off `Env` — the backend
  * default and the K8s namespace fallback. Composition roots map their
@@ -62,6 +62,25 @@ export interface CreateSandboxClientConfig {
     refStorePath?: string;
     /** Docker: force the container platform (e.g. `linux/amd64`) so the sandbox matches the mounted lib store's arch. */
     platform?: string;
+    /**
+     * Docker: unix socket of the Docker-API engine to dial — a Docker daemon
+     * socket or a podman Docker-compat socket. Unset preserves dockerode's
+     * default resolution (`DOCKER_HOST`, then the default Docker socket).
+     */
+    engineSocketPath?: string;
+    /**
+     * Docker: the engine's bind mounts expose honest host file ownership to
+     * the container — podman machine's virtiofs and native Linux binds present
+     * the embedder user's real uid and modes, which the uid-1000 sandbox
+     * workload cannot write; Docker Desktop's file-sharing layer masks that
+     * mismatch, so it stays unset there. When set, the client loosens each
+     * step's pre-created write tree so workload writes land. The field names
+     * the engine fact rather than the remediation, so how the harness
+     * compensates can evolve without changing the embedder surface; a
+     * single-valued union (not a boolean) so future ownership classes extend
+     * it without a breaking change.
+     */
+    engineBindOwnership?: "host-preserved";
     /** K8s: PVC claim backing the session PVC the workspace roots live under. */
     sessionPvc?: string;
     /**
@@ -87,7 +106,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;
@@ -100,6 +119,25 @@ export interface CreateSandboxClientConfig {
  * Exported for tests.
  */
 export declare function composeAwaitOptions(base: AwaitExecOptions | undefined, transport: SandboxTransport, isAlive: NonNullable<AwaitExecOptions["isAlive"]>): AwaitExecOptions;
+/**
+ * Backend-agnostic pre-creation of the writable step tree under the analysis's
+ * resolved workspace root. On Docker that root is the host dir the container
+ * binds; on K8s it lives under the session PVC the sandbox pod mounts via
+ * subPath. `mkdir(recursive)` is idempotent, so an existing tree (replay, retry)
+ * is not an error. A read-only sandbox has no writable step mount, so there is
+ * nothing to pre-create.
+ *
+ * `stepTreeAccess: "world-writable"` chmods the step dir and each subdir so the
+ * uid-1000 sandbox workload can write them through engines that honor host bind
+ * ownership. The chmod is explicit, not `mkdir`'s `mode` option: the process
+ * umask masks `mkdir`'s mode, and on replay the dirs already exist so `mkdir`
+ * would not touch them either way. Scoped to the step write tree — the
+ * read-only mount sources are never re-moded. Exported for tests.
+ */
+export declare function precreateStepTree(deps: {
+    resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    stepTreeAccess?: "world-writable";
+}, meta: CreateSandboxMeta): Promise<void>;
 export declare function createSandboxClient(config: CreateSandboxClientConfig): SandboxClient;
 /** Re-exports so consumers import once from this module. */
 export { clearSandboxRef };

package/dist/sandbox/create-sandbox.js

@@ -11,7 +11,7 @@
  * coupling (they just call the closures we hand them). `submitExec` and
  * `awaitExec` are backend-agnostic — they only need the SandboxRef.
  */
-import { mkdir } from "node:fs/promises";
+import { chmod, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { clampResources } from "../config/resource-limits.js";
 import { stepWritePrefix } from "../workspace/paths.js";
@@ -34,6 +34,36 @@ import { toPersistedRef } from "./types.js";
 export function composeAwaitOptions(base, transport, isAlive) {
     return { isAlive, ...base, transport };
 }
+/**
+ * Backend-agnostic pre-creation of the writable step tree under the analysis's
+ * resolved workspace root. On Docker that root is the host dir the container
+ * binds; on K8s it lives under the session PVC the sandbox pod mounts via
+ * subPath. `mkdir(recursive)` is idempotent, so an existing tree (replay, retry)
+ * is not an error. A read-only sandbox has no writable step mount, so there is
+ * nothing to pre-create.
+ *
+ * `stepTreeAccess: "world-writable"` chmods the step dir and each subdir so the
+ * uid-1000 sandbox workload can write them through engines that honor host bind
+ * ownership. The chmod is explicit, not `mkdir`'s `mode` option: the process
+ * umask masks `mkdir`'s mode, and on replay the dirs already exist so `mkdir`
+ * would not touch them either way. Scoped to the step write tree — the
+ * read-only mount sources are never re-moded. Exported for tests.
+ */
+export async function precreateStepTree(deps, meta) {
+    if (meta.readOnly)
+        return;
+    const stepDir = stepWritePrefix({
+        workspaceRoot: deps.resolveWorkspaceRoot(meta.analysisId),
+        runId: meta.runId,
+        stepId: meta.stepId,
+    });
+    await mkdir(stepDir, { recursive: true });
+    await Promise.all(STEP_SUBDIRS.map((sub) => mkdir(join(stepDir, sub), { recursive: true })));
+    if (deps.stepTreeAccess === "world-writable") {
+        await chmod(stepDir, 0o777);
+        await Promise.all(STEP_SUBDIRS.map((sub) => chmod(join(stepDir, sub), 0o777)));
+    }
+}
 export function createSandboxClient(config) {
     const backend = config.backend ?? config.env.backend;
     const transport = config.transport ?? "poll";
@@ -64,26 +94,10 @@ export function createSandboxClient(config) {
             libStorePath: config.libStorePath,
             refStorePath: config.refStorePath,
             platform: config.platform,
+            engineSocketPath: config.engineSocketPath,
             logger: config.logger,
             registerSandbox,
         });
-    // Backend-agnostic pre-creation of the writable step tree under the
-    // analysis's resolved workspace root. On Docker that root is the host dir
-    // the container binds; on K8s it lives under the session PVC the sandbox
-    // pod mounts via subPath. mkdir(recursive) is idempotent, so an existing
-    // tree (replay, retry) is not an error.
-    const precreateStepTree = async (meta) => {
-        // A read-only sandbox has no writable step mount — nothing to pre-create.
-        if (meta.readOnly)
-            return;
-        const stepDir = stepWritePrefix({
-            workspaceRoot: config.resolveWorkspaceRoot(meta.analysisId),
-            runId: meta.runId,
-            stepId: meta.stepId,
-        });
-        await mkdir(stepDir, { recursive: true });
-        await Promise.all(STEP_SUBDIRS.map((sub) => mkdir(join(stepDir, sub), { recursive: true })));
-    };
     // `teardown` needs the registry-clear closure but the SandboxRef alone
     // doesn't carry runId/stepId. Wrap the backend impl so callers pass the
     // ref + step coordinates and the wrapper does the clear after the
@@ -109,7 +123,13 @@ export function createSandboxClient(config) {
     const isAlive = async (ref) => unwrapOrThrow(await ops.isAlive(ref));
     return {
         createSandbox: async (meta, identity) => {
-            await precreateStepTree(meta);
+            // The config states an engine fact (binds preserve host ownership);
+            // which remediation that fact demands — today, a world-writable step
+            // write tree — is harness-owned and chosen here, not by the embedder.
+            await precreateStepTree({
+                resolveWorkspaceRoot: config.resolveWorkspaceRoot,
+                stepTreeAccess: config.engineBindOwnership === "host-preserved" ? "world-writable" : undefined,
+            }, meta);
             // Every caller must declare resources — a sandbox with no cpu/memory
             // request is a semantic error, not something to paper over with a
             // default (a DBOS replay of a pre-resources workflow input lands here).

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";
@@ -53,6 +53,13 @@ export interface DockerClientConfig {
      * create rather than crashing inside the sandbox.
      */
     platform?: string;
+    /**
+     * Unix socket of the Docker-API engine to dial — a Docker daemon socket or a
+     * podman Docker-compat socket (both serve the identical REST API). Unset
+     * preserves dockerode's default resolution (`DOCKER_HOST`, then the default
+     * Docker socket).
+     */
+    engineSocketPath?: string;
     /** Injected for tests. */
     docker?: Docker;
     /** Injected for tests so `/health` polling can be stubbed. */
@@ -62,10 +69,18 @@ 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>;
 }
+/**
+ * dockerode connection options for a configured engine socket, or `undefined`
+ * to leave construction as a bare `new Docker()` — which preserves dockerode's
+ * default resolution (`DOCKER_HOST`, then the default Docker socket). A set
+ * `engineSocketPath` dials that unix socket instead (a Docker daemon or a
+ * podman Docker-compat socket).
+ */
+export declare function engineConnectionOptions(engineSocketPath: string | undefined): Docker.DockerOptions | undefined;
 export declare function createDockerSandboxOps(config: DockerClientConfig): {
     createSandbox(meta: CreateSandboxMeta, identity: SandboxIdentity): ResultAsync<SandboxRef, SandboxError>;
     teardown(ref: SandboxRef): ResultAsync<void, SandboxError>;

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";
@@ -96,36 +97,58 @@ async function pollHealth(fetchImpl, url, timeoutMs) {
     }
     throw new Error(`sandbox /health did not return 200 within ${timeoutMs}ms: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
 }
+/**
+ * dockerode connection options for a configured engine socket, or `undefined`
+ * to leave construction as a bare `new Docker()` — which preserves dockerode's
+ * default resolution (`DOCKER_HOST`, then the default Docker socket). A set
+ * `engineSocketPath` dials that unix socket instead (a Docker daemon or a
+ * podman Docker-compat socket).
+ */
+export function engineConnectionOptions(engineSocketPath) {
+    return engineSocketPath === undefined ? undefined : { socketPath: engineSocketPath };
+}
 /**
  * Create the container, or adopt the one already standing under this
- * checkpointed name (a recovery re-run, see the harness-sandbox-exec spec). A
- * running container is adopted as-is; a stopped prior attempt is removed and
- * recreated. A 409 whose container belongs to a different workflow is a refused
- * name collision — never adopt or remove someone else's container.
+ * checkpointed name on a recovery re-run. Any create failure triggers an
+ * inspect of the name: engines disagree on the duplicate-name status (Docker
+ * answers 409, podman's compat API 500), so the reconcile keys on whether a
+ * container stands under the name, not on a status code. A standing container
+ * this workflow owns is adopted as-is if running, removed and recreated if
+ * stopped; one owned by a different workflow is a refused name collision — never
+ * adopt or remove someone else's container. When no container stands, the
+ * failure was not a name collision and the original create error is returned;
+ * the inspect's own failure is never surfaced, so a transient engine outage
+ * (both calls fail) still reports the create failure.
  */
-async function createOrAdopt(docker, createOpts, name, ownerWorkflowId, createFailed) {
+async function createOrAdopt(docker, createOpts, name, ownerWorkflowId, createFailed, logger) {
     const created = await trySandbox(() => docker.createContainer(createOpts), createFailed);
     if (created.isOk())
         return ok({ container: created.value, alreadyRunning: false });
-    if (statusOf(created.error) !== 409)
-        return err(created.error);
     const existing = docker.getContainer(name);
     const inspected = await trySandbox(() => existing.inspect(), createFailed);
+    // No container stands under the name → the create failure was not a name
+    // collision, so surface the original create error rather than the inspect's.
     if (inspected.isErr())
-        return err(inspected.error);
+        return err(created.error);
     const info = inspected.value;
     const owner = info.Config?.Labels?.[OWNER_WORKFLOW_LABEL];
     if (owner !== ownerWorkflowId) {
         return err({ type: "name_conflict", op: "docker.createSandbox", sandboxId: name, owner: owner ?? null });
     }
-    if (info.State.Running)
+    // Both mutating reconcile outcomes are logged: adoption reuses a container the
+    // current attempt did not create, so without a record here nothing ties the
+    // step's sandbox back to the prior attempt that made it.
+    if (info.State.Running) {
+        logger.info("adopted standing container on recovery re-run", { sandboxId: name, ownerWorkflowId });
         return ok({ container: existing, alreadyRunning: true });
+    }
     const removed = await removeContainerIgnoreMissing(docker, name);
     if (removed.isErr())
         return err(removed.error);
     const recreated = await trySandbox(() => docker.createContainer(createOpts), createFailed);
     if (recreated.isErr())
         return err(recreated.error);
+    logger.info("removed stopped prior attempt and recreated", { sandboxId: name, ownerWorkflowId });
     return ok({ container: recreated.value, alreadyRunning: false });
 }
 function removeContainerIgnoreMissing(docker, sandboxId) {
@@ -144,7 +167,11 @@ function removeContainerIgnoreMissing(docker, sandboxId) {
     statusOf(e) === 404 ? ok(undefined) : err(e));
 }
 export function createDockerSandboxOps(config) {
-    const docker = config.docker ?? new Docker();
+    // The injected test instance wins; otherwise a configured socket dials that
+    // engine and an unset one stays a bare `new Docker()` (default resolution).
+    const connection = engineConnectionOptions(config.engineSocketPath);
+    const docker = config.docker ?? (connection ? new Docker(connection) : new Docker());
+    const logger = (config.logger ?? createNoopLogger()).named("docker-client");
     const fetchImpl = config.fetch ?? fetch;
     const transport = config.transport ?? "poll";
     const pollMode = transport === "poll";
@@ -158,7 +185,7 @@ 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)");
+                    logger.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,
@@ -231,7 +258,7 @@ export function createDockerSandboxOps(config) {
                         AutoRemove: false,
                     },
                 };
-                const sandbox = await createOrAdopt(docker, createOpts, sandboxId, meta.childWorkflowId, createFailed);
+                const sandbox = await createOrAdopt(docker, createOpts, sandboxId, meta.childWorkflowId, createFailed, logger);
                 if (sandbox.isErr())
                     return err(sandbox.error);
                 if (!sandbox.value.alreadyRunning) {

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/state/init.d.ts

@@ -7,8 +7,9 @@
  * simultaneous startups don't race on DDL.
  */
 import type { Pool } from "pg";
+import type { Logger } from "../lib/logger.js";
 /**
  * Initialize Cortex state tables. Safe to call on every startup and across
  * concurrent replicas (advisory lock serializes the init flow).
  */
-export declare function initCortexState(pool: Pool): Promise<void>;
+export declare function initCortexState(pool: Pool, injected?: Logger): Promise<void>;

package/dist/state/init.js

@@ -7,6 +7,7 @@
  * simultaneous startups don't race on DDL.
  */
 import { backfillAiSdkMessageEnvelopes } from "../memory/message-backfill.js";
+import { createNoopLogger } from "../lib/console-logger.js";
 const DDL = `
 -- Analysis-level state (status, context, data-profile tracking, billing identity).
 --
@@ -245,7 +246,8 @@ CREATE TABLE IF NOT EXISTS cortex_working_memory (
  * Initialize Cortex state tables. Safe to call on every startup and across
  * concurrent replicas (advisory lock serializes the init flow).
  */
-export async function initCortexState(pool) {
+export async function initCortexState(pool, injected) {
+    const logger = (injected ?? createNoopLogger()).named("cortex-state");
     const client = await pool.connect();
     try {
         // Serialize concurrent replica startups — cheap, no extra tooling.
@@ -381,11 +383,8 @@ export async function initCortexState(pool) {
            WITH (m = 16, ef_construction = 64)`);
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[state-init] Could not create HNSW index on cortex_regulatory_chunks.embedding ` +
-                    `(pgvector < 0.5.0 or operator class unavailable): ${msg}. ` +
-                    `Cosine similarity queries will fall back to sequential scan. ` +
-                    `Upgrade pgvector and re-run init to get the ANN index.`);
+                logger.warn("could not create HNSW index on cortex_regulatory_chunks.embedding (pgvector < 0.5.0 or operator class unavailable) — " +
+                    "cosine similarity queries fall back to sequential scan; upgrade pgvector and re-run init to get the ANN index", logger.errorFields(err));
             }
             // No boot-time orphan sweep on cortex_runs / cortex_step_executions.
             // Every running row is backed by a DBOS workflow (executeAnalysis,

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

@@ -21,6 +21,7 @@ import { type AuthContext, type RunSession } from "../auth/types.js";
 import type { RunAuthorization, RunAuthorizer } from "../execution/run-authorizer.js";
 import type { StagedInput } from "../execution/staged-input.js";
 import type { BioToolKeys } from "../tools/bio/keys.js";
+import type { Logger } from "../lib/logger.js";
 import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
 import type { SandboxClient } from "../sandbox/client.js";
 import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
@@ -29,6 +30,8 @@ import { type ProfilerOutput } from "../schemas/data-profile-schemas.js";
 import { type DataProfileInputFile, type DataProfileResult } from "../state/index.js";
 /** The body's construction-time deps — closed over at registration. */
 export interface DataProfileDeps {
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
     readonly provider: ChatProvider;
     readonly pool: Pool;
     readonly sandboxClient: SandboxClient;
@@ -130,6 +133,8 @@ export type DataProfileTriggerResult = "started" | "restarted" | "already_runnin
  * (`registerDataProfileWorkflow`); the route never holds them.
  */
 export interface DataProfileTriggerDeps {
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
     readonly pool: Pool;
     readonly runAuthorizer: RunAuthorizer;
     readonly workflow: (input: DataProfileWorkflowInput) => Promise<void>;