@inflexa-ai/harness 0.2.0 → 0.3.0

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/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>;

package/dist/tasks/data-profile.js

@@ -23,6 +23,7 @@ import { forSubAgent } from "../auth/types.js";
 import { createDataProfilerAgent } from "../agents/sandbox/data-profiler.js";
 import { runToTerminal } from "../loop/run-to-terminal.js";
 import { durableStep } from "../loop/run-step.js";
+import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { defineTool } from "../tools/define-tool.js";
 import { renderWorkspace } from "../prompts/briefing.js";
@@ -128,6 +129,7 @@ export function registerDataProfileWorkflow(deps) {
  * 'failed' on error, and revokes the run authorization on every terminal path.
  */
 export async function runDataProfileBody(input, deps) {
+    const logger = (deps.logger ?? createNoopLogger()).named("data-profile").with({ analysisId: input.analysisId });
     // Ownership defaults to true for inputs persisted before the field existed
     // (a #247 workflow recovered across this deploy): those were always
     // Cortex-owned and must be revoked here.
@@ -138,9 +140,9 @@ export async function runDataProfileBody(input, deps) {
         // embedder populated the tree and handed us this manifest in the workflow
         // input. The body never downloads.
         if (stagedInputs.length === 0) {
-            console.warn(`[data-profile] No input files staged for ${analysisId}`);
+            logger.warn("no input files staged");
             if (!unwrapOrThrow(await completeDataProfile(deps.pool, analysisId)))
-                logTerminalNoop(analysisId, "completion");
+                logTerminalNoop(logger, analysisId, "completion");
             await deps.runAuthorizer.revoke(authorization, "data-profile-completed");
             return;
         }
@@ -190,7 +192,7 @@ export async function runDataProfileBody(input, deps) {
             ``,
             `All file paths in your response must be relative to the analysis root and must EXACTLY match the paths listed above.`,
         ].join("\n");
-        console.log(`[data-profile] execution=${executionId} analysis=${analysisId} starting sandbox`);
+        logger.info("starting sandbox", { executionId });
         const sandbox = await deps.sandboxClient.createSandbox({
             runId: DATA_PROFILE_RUN_LITERAL,
             stepId: DATA_PROFILE_STEP_LITERAL,
@@ -310,13 +312,16 @@ export async function runDataProfileBody(input, deps) {
                 indexed++;
             }
             if (fallbackCount > 0) {
-                console.warn(`[data-profile] ${fallbackCount}/${stagedInputs.length} input file(s) used a deterministic fallback description (analysis=${analysisId}) — profiler omitted them`);
+                logger.warn("input file(s) used a deterministic fallback description — profiler omitted them", {
+                    fallbackCount,
+                    stagedCount: stagedInputs.length,
+                });
             }
-            console.log(`[data-profile] Indexed ${indexed} file(s) for ${analysisId}`);
+            logger.info("indexed file(s)", { indexed });
             // 5. Complete — store the FULL profiler finding plus the input snapshot for
             // staleness detection. The scratch tree is gone; this row is all that survives.
             if (!unwrapOrThrow(await completeDataProfile(deps.pool, analysisId, buildDataProfileResult(profilerData, stagedInputs, new Date().toISOString())))) {
-                logTerminalNoop(analysisId, "completion");
+                logTerminalNoop(logger, analysisId, "completion");
             }
             await deps.runAuthorizer.revoke(authorization, "data-profile-completed");
         }
@@ -325,14 +330,14 @@ export async function runDataProfileBody(input, deps) {
                 await deps.sandboxClient.teardown(sandbox);
             }
             catch (teardownErr) {
-                console.warn(`[data-profile] execution=${executionId} teardown failed (non-fatal):`, teardownErr);
+                logger.warn("teardown failed (non-fatal)", { executionId, ...logger.errorFields(teardownErr) });
             }
         }
     }
     catch (err) {
-        console.error(`[data-profile] Failed for ${analysisId}:`, err);
+        logger.error("profile failed", logger.errorFields(err));
         if (!unwrapOrThrow(await failDataProfile(deps.pool, analysisId, profileFailureReason(err))))
-            logTerminalNoop(analysisId, "failure");
+            logTerminalNoop(logger, analysisId, "failure");
         await deps.runAuthorizer.revoke(authorization, "data-profile-failed");
     }
 }
@@ -342,8 +347,8 @@ export async function runDataProfileBody(input, deps) {
  * there is no `running` row to stamp. Not an error — the ledger correctly moved
  * on; the workflow still revokes its own authorization on the same terminal path.
  */
-function logTerminalNoop(analysisId, write) {
-    console.warn(`[data-profile] ${write} write skipped for ${analysisId}: ledger row not running (cleared or expired concurrently)`);
+function logTerminalNoop(logger, analysisId, write) {
+    logger.warn("terminal write skipped: ledger row not running (cleared or expired concurrently)", { analysisId, write });
 }
 /**
  * Resolve the `RunSession` the workflow runs under. Whether the authorization
@@ -409,6 +414,7 @@ async function startDataProfileWorkflow(deps, params) {
  * Returns what happened, so the caller can surface it (e.g. in the seed response).
  */
 export async function triggerDataProfile(deps, params) {
+    const logger = (deps.logger ?? createNoopLogger()).named("data-profile").with({ analysisId: params.analysisId });
     const { analysisId } = params;
     try {
         // ADVISORY pre-check, not the enforcement — the claim CAS carries the same seed
@@ -420,7 +426,7 @@ export async function triggerDataProfile(deps, params) {
         // a NULL-seed row (`loadDataProfileStatus` would hide the seed of a cleared row).
         const seeded = unwrapOrThrow(await loadSeedInputFileIds(deps.pool, analysisId));
         if (seeded === null || seeded.length === 0) {
-            console.error(`[data-profile] Trigger rejected for ${analysisId}: no seeded input set (missing analysis row or caller skipped seeding)`);
+            logger.error("trigger rejected: no seeded input set (missing analysis row or caller skipped seeding)");
             return "failed";
         }
         // The trigger validates the ledger seed above; it must also validate the manifest
@@ -429,7 +435,7 @@ export async function triggerDataProfile(deps, params) {
         // NULL result while the seed still names files, an incoherence a staleness policy
         // then loops on re-triggering. Refuse the divergence before any claim.
         if (params.stagedInputs.length === 0) {
-            console.error(`[data-profile] Trigger rejected for ${analysisId}: empty manifest dispatched against a seed naming ${seeded.length} file(s)`);
+            logger.error("trigger rejected: empty manifest dispatched against a non-empty seed", { seededCount: seeded.length });
             return "failed";
         }
         const started = unwrapOrThrow(await tryStartDataProfile(deps.pool, analysisId));
@@ -448,7 +454,7 @@ export async function triggerDataProfile(deps, params) {
         return "failed";
     }
     catch (err) {
-        console.error(`[data-profile] Trigger error for ${analysisId}:`, err);
+        logger.error("trigger error", logger.errorFields(err));
         return "failed";
     }
 }
@@ -462,17 +468,18 @@ export async function triggerDataProfile(deps, params) {
  * there is no further channel to report it on.
  */
 async function compensateStartFailure(deps, analysisId, phase, err) {
-    console.error(`[data-profile] ${phase} error for ${analysisId}:`, err);
+    const logger = (deps.logger ?? createNoopLogger()).named("data-profile").with({ analysisId });
+    logger.error("start failed", { phase, ...logger.errorFields(err) });
     const failed = await failDataProfile(deps.pool, analysisId, profileFailureReason(err));
     if (failed.isErr()) {
-        console.error(`[data-profile] Failed to mark ${analysisId} failed after a start error:`, failed.error);
+        logger.error("failed to mark failed after a start error", { phase, err: failed.error });
     }
     else if (!failed.value) {
         // The row this compensation was written to fail is no longer `running` — a
         // concurrent clear/expire already moved it on, so the running-CAS refused the
         // stamp. Nothing wedged at `running`, which is the outcome compensation exists
         // to guarantee; just record the no-op.
-        logTerminalNoop(analysisId, "compensation");
+        logTerminalNoop(logger, analysisId, "compensation");
     }
 }
 /**

package/dist/tools/bio/search-dgidb.d.ts

@@ -8,6 +8,7 @@
  *   - searchType="gene": input HUGO symbols, returns drugs interacting with each.
  *   - searchType="drug": input drug names/concept IDs, returns genes each acts on.
  */
+import type { Logger } from "../../lib/logger.js";
 interface Interaction {
     geneName: string;
     drugName: string;
@@ -26,7 +27,16 @@ interface Interaction {
         value: string;
     }[];
 }
-export declare const searchDgidbTool: import("../define-tool.js").Tool<{
+/**
+ * A factory rather than a bare const (unlike its bio-leaf siblings) because it
+ * logs: DGIdb answers GraphQL partial errors alongside usable data, and an
+ * operator debugging odd interaction results needs to see them. `ToolContext`
+ * carries no deps by design, so a tool that logs is dep-bearing — the same
+ * reason `createSearchClinvarTool` takes its key that way.
+ */
+export declare function createSearchDgidbTool(deps?: {
+    readonly logger?: Logger;
+}): import("../define-tool.js").Tool<{
     query: string | string[];
     searchType: "drug" | "gene";
     minSources: number;