@inflexa-ai/harness 0.2.0 → 0.4.0

package/dist/workflows/execute-target-assessment.js

@@ -33,6 +33,7 @@
 import { DBOS } from "@dbos-inc/dbos-sdk";
 import { z } from "zod";
 import { forSubAgent } from "../auth/types.js";
+import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { resolveTarget } from "../tools/lib/identifier-resolver.js";
 import { TargetAssessmentInputSchema } from "./target-assessment/schemas.js";
@@ -111,6 +112,7 @@ export function registerExecuteTargetAssessment(deps) {
  * (the DBOS calls inside still rely on a workflow context being present).
  */
 export async function runExecuteTargetAssessmentBody(input, deps) {
+    const logger = (deps.logger ?? createNoopLogger()).with({ assessmentId: input.assessmentId });
     // (§6.1) Outermost try/finally — every termination path dispatches the
     // matching terminal handler. Phase 0 throws are caught here; every
     // other phase wraps its body in coverage envelopes and does not throw.
@@ -137,7 +139,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         // (§5.3, §6.3) Phase 0 — target resolution. The only legitimate throw
         // site. On throw, the catch below records `phase0Error` and the
         // terminal block dispatches `markFailed({kind: "target-unresolved"})`.
-        await emitProgress(deps.pool, input.assessmentId, "resolving");
+        await emitProgress(deps.pool, logger, input.assessmentId, "resolving");
         const resolved = await DBOS.runStep(async () => {
             const r = await resolveTarget(input.target);
             return {
@@ -154,7 +156,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         // returns the cached envelope. The per-collector run functions emit
         // different bundle shapes; the union is widened to `unknown` here
         // and `Phase1Bundle` is reconstructed by manifest key below.
-        await emitProgress(deps.pool, input.assessmentId, "collecting");
+        await emitProgress(deps.pool, logger, input.assessmentId, "collecting");
         const manifest = COLLECTOR_MANIFEST;
         const collectorCtx = { ncbiApiKey: deps.ncbiApiKey };
         const collectorPairs = await Promise.all(manifest.map((entry) => DBOS.runStep(() => entry.run(resolved, collectorCtx), {
@@ -185,7 +187,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         // (§5.5, §5.11) Phase 2 — decisions. Lazy billing resolution happens
         // inside the chat provider's closure (TA-aware provider in §12). The
         // session carries the `billingContextId` the provider reads from.
-        await emitProgress(deps.pool, input.assessmentId, "deciding");
+        await emitProgress(deps.pool, logger, input.assessmentId, "deciding");
         const decisionSession = buildSession(input, "ta-decisions");
         const [modulatorRes, drugsRes] = await Promise.all([
             modulatorTriage(phase1, {
@@ -226,7 +228,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         // (§5.6) Phase 3 — fan-out blocks. Each block iterates items via
         // Promise.all over DBOS.runStep; `withHost` semaphores inside each
         // item function cap concurrency to 4 per host.
-        await emitProgress(deps.pool, input.assessmentId, "fanning_out");
+        await emitProgress(deps.pool, logger, input.assessmentId, "fanning_out");
         const triage = phase2.decisions.modulatorTriage;
         const triageShortlist = triage.coverage === "available"
             ? triage.data.shortlist.map((m) => ({
@@ -287,7 +289,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             },
         };
         // (§5.7) Phase 4 — deterministic assembly. Single DBOS step.
-        await emitProgress(deps.pool, input.assessmentId, "assembling");
+        await emitProgress(deps.pool, logger, input.assessmentId, "assembling");
         const phase4 = await DBOS.runStep(() => phase4Assemble(deps.pool, phase3), { name: "ta-phase4-assemble" });
         // (§5.8-pre) Approval-precedent grounding — one deterministic openFDA
         // lookup, rendered to markdown and injected into every synthesis prompt.
@@ -301,14 +303,14 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
                     result = await fetchApprovalPrecedents({ indication });
                 }
                 catch (err) {
-                    console.warn(`[ta-approval-precedents] openFDA lookup failed for "${indication}": ${err instanceof Error ? err.message : err}`);
+                    logger.named("ta-approval-precedents").warn("openFDA lookup failed", { indication, ...logger.errorFields(err) });
                     result = null;
                 }
             }
             return renderApprovalPrecedents(indication, result);
         }, { name: "ta-approval-precedents" });
         // (§5.8) Phase 5 — three per-section syntheses in parallel.
-        await emitProgress(deps.pool, input.assessmentId, "synthesizing");
+        await emitProgress(deps.pool, logger, input.assessmentId, "synthesizing");
         const synthesisDeps = (agentId) => ({
             chatProvider: deps.chatProvider,
             session: { ...buildSession(input, agentId) },
@@ -343,6 +345,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         // and returns the persisted-shape bundle. Schema/derived violations
         // throw and the terminal handler dispatches to `markFailed`.
         const persisted = await DBOS.runStep(() => phase5Persist({
+            logger,
             assessmentId: input.assessmentId,
             phase4Dossier: phase4.dossier,
             phase2,
@@ -390,10 +393,10 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             await DBOS.runStep(async () => unwrapOrThrow(await setDossier(deps.pool, input.assessmentId, dossierForPersist)), {
                 name: "ta-terminal-completed",
             });
-            await emitProgress(deps.pool, input.assessmentId, "completed");
+            await emitProgress(deps.pool, logger, input.assessmentId, "completed");
         }
         catch (err) {
-            console.error(`[ta-terminal] setDossier failed for ${input.assessmentId}: ${err instanceof Error ? err.message : err}`);
+            logger.named("ta-terminal").error("setDossier failed", logger.errorFields(err));
         }
         await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-completed");
         recordTerminalReason("completed");
@@ -409,7 +412,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             kind: "target-unresolved",
             message: phase0Error instanceof Error ? phase0Error.message : String(phase0Error),
         })), { name: "ta-terminal-failed-resolve" });
-        await emitProgress(deps.pool, input.assessmentId, "failed");
+        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
         await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
         recordTerminalReason("target-unresolved");
         return {
@@ -425,7 +428,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             message: schemaViolation.message,
             details: schemaViolation.issues,
         })), { name: "ta-terminal-failed-schema" });
-        await emitProgress(deps.pool, input.assessmentId, "failed");
+        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
         await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
         recordTerminalReason("schema-violation");
         return {
@@ -440,7 +443,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             kind: "derived-invariant-violation",
             message: derivedViolation.message,
         })), { name: "ta-terminal-failed-derived" });
-        await emitProgress(deps.pool, input.assessmentId, "failed");
+        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
         await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
         recordTerminalReason("derived-invariant-violation");
         return {
@@ -459,7 +462,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             name: "ta-terminal-drain-marker",
         }).catch(() => null);
         await DBOS.runStep(async () => unwrapOrThrow(await markAssessmentSuspended(deps.pool, input.assessmentId)), { name: "ta-terminal-suspended" });
-        await emitProgress(deps.pool, input.assessmentId, "suspended");
+        await emitProgress(deps.pool, logger, input.assessmentId, "suspended");
         await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-canceled");
         const workflowId = DBOS.workflowID;
         if (workflowId) {
@@ -485,7 +488,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             kind: "unexpected-throw",
             message: unexpectedError instanceof Error ? unexpectedError.message : String(unexpectedError),
         })), { name: "ta-terminal-failed-unexpected" });
-        await emitProgress(deps.pool, input.assessmentId, "failed");
+        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
         await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
         recordTerminalReason("unexpected-throw");
         return {
@@ -514,13 +517,14 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
  * aborted by a transient revoke failure.
  */
 async function revokeRunAuthorizationSafe(deps, authorization, reason) {
+    const logger = (deps.logger ?? createNoopLogger()).named("execute-target-assessment");
     try {
         await DBOS.runStep(() => deps.runAuthorizer.revoke(authorization, reason), {
             name: `ta-revoke-run-auth:${reason}`,
         });
     }
     catch (err) {
-        console.warn(`[execute-target-assessment] revokeRunAuthorization (${reason}) failed:`, err instanceof Error ? err.message : err);
+        logger.warn("revokeRunAuthorization failed", { reason, ...logger.errorFields(err) });
     }
 }
 // Re-export the canonical TA input schema (consumers and the managed root

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

@@ -27,6 +27,7 @@
  * its own self-cancel on 402.
  */
 import type { Pool } from "pg";
+import type { Logger } from "../lib/logger.js";
 import type { AgentDefinition, LoopMessage } from "../loop/types.js";
 import type { AgentChat, EmbeddingProvider } from "../providers/types.js";
 import { type RunSession } from "../auth/types.js";
@@ -183,6 +184,14 @@ export interface SandboxAgentBuildContext {
  */
 export interface SandboxStepDeps {
     readonly pool: Pool;
+    /**
+     * Operational logging seam. Omit it and the body falls back to a no-op —
+     * but a failed step's cause is written here and NOWHERE else (`failStep`
+     * scrubs the error before it reaches the DB row, the run panel, or the
+     * parent's re-raise), so an embedder that wires nothing gives up its only
+     * account of why a step died.
+     */
+    readonly logger?: Logger;
     /** Non-streaming chat — drives the agent loop + the post-step sub-agents. */
     readonly provider: AgentChat;
     /** Write-side embedder for the post-step vector index. */

package/dist/workflows/sandbox-step.js

@@ -28,6 +28,7 @@
  */
 import { DBOS, Error as DBOSErrors } from "@dbos-inc/dbos-sdk";
 import { insertStepExecution, updateStepExecution } from "../state/index.js";
+import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { isBudgetExceeded } from "../loop/budget-exceeded.js";
 import { runAgent } from "../loop/run-agent.js";
@@ -101,6 +102,14 @@ export function registerSandboxStep(deps) {
  * (the DBOS calls inside still rely on a workflow context being present).
  */
 async function runSandboxStepBody(input, deps) {
+    // Step coordinates bind once — every record below carries them without each
+    // call site restating them. REPLAY: a recovered workflow re-executes this body
+    // and re-emits its records, so a reader dedups by (runId, stepId), not by count.
+    const logger = (deps.logger ?? createNoopLogger()).named("sandbox-step").with({
+        runId: input.runId,
+        stepId: input.stepId,
+        agentId: input.agentId,
+    });
     const childWorkflowId = DBOS.workflowID ?? `${input.runId}-${input.stepId}`;
     // Checkpointed so the value (and every `durationMs` derived from it) replays
     // identically — a raw `Date.now()` in the workflow body drifts on recovery.
@@ -206,7 +215,7 @@ async function runSandboxStepBody(input, deps) {
             await emitToParentStream(part);
         }
         catch (err) {
-            console.warn(`[sandbox-step] emitToParentStream failed (non-fatal):`, err instanceof Error ? err.message : err);
+            logger.warn("emitToParentStream failed (non-fatal)", logger.errorFields(err));
         }
     };
     // Schema-conformant step-activity emitter — stable id per (runId, stepId)
@@ -230,10 +239,15 @@ async function runSandboxStepBody(input, deps) {
     const failStep = async (errorClass, err) => {
         if (err instanceof DBOSErrors.DBOSWorkflowCancelledError)
             throw err;
-        await tryTeardown(deps, sandbox);
+        await tryTeardown(logger, deps, sandbox);
         const durationMs = (await DBOS.now()) - startedAt;
-        const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
-        console.error(`[sandbox-step] ${errorClass} failure for ${input.runId}/${input.stepId}: ${detail}`);
+        // The scrub below is deliberate and load-bearing, which makes this record
+        // the ONLY account of why the step died — the thrown error carries just the
+        // generic phrase, so nothing downstream can reconstruct the cause.
+        logger.error("step failure", {
+            errorClass,
+            ...logger.errorFields(err),
+        });
         const safe = userFacingStepFailure(errorClass);
         await DBOS.runStep(async () => {
             unwrapOrThrow(await updateStepExecution(deps.pool, input.runId, input.stepId, {
@@ -334,7 +348,9 @@ async function runSandboxStepBody(input, deps) {
                 await DBOS.runStep(() => DBOS.send(input.parentWorkflowId, notification, BUDGET_EXCEEDED_TOPIC), { name: "notify-parent-budget-exceeded" });
             }
             catch (sendErr) {
-                console.warn(`[sandbox-step] notify-parent-budget-exceeded failed (non-fatal): ${sendErr instanceof Error ? sendErr.message : sendErr}`);
+                logger.warn("notify-parent-budget-exceeded failed (non-fatal)", {
+                    ...logger.errorFields(sendErr),
+                });
             }
             // Self-cancel to CANCELLED so the parent's `getResult` observes the
             // cancellation and triggers the 402 pause cascade. ERROR is NOT
@@ -369,7 +385,7 @@ async function runSandboxStepBody(input, deps) {
     // terminal-failure status so the parent's fail-fast cascade fires.
     const blockerOutcome = blockerHolder.outcome;
     if (blockerOutcome) {
-        await tryTeardown(deps, sandbox);
+        await tryTeardown(logger, deps, sandbox);
         const durationMs = (await DBOS.now()) - startedAt;
         await DBOS.runStep(async () => {
             unwrapOrThrow(await updateStepExecution(deps.pool, input.runId, input.stepId, {
@@ -413,7 +429,7 @@ async function runSandboxStepBody(input, deps) {
         lineageCollector,
     };
     await emitActivity("generating-metadata", "Describing output files");
-    const manifest = await safeRunValue(() => walkStepArtifacts({
+    const manifest = await safeRunValue(logger, () => walkStepArtifacts({
         writePrefix,
         stepId: input.stepId,
         runId: input.runId,
@@ -423,11 +439,11 @@ async function runSandboxStepBody(input, deps) {
     // gate (`data-step-summary`, file-tree) stay replay-stable and the billed
     // LLM calls are not re-issued on recovery. The remaining stages (walk /
     // reconcile / sync / index) stay inline — a separate follow-up.
-    const metadataEntries = await safeRunValue(() => DBOS.runStep(() => generateStepFileMetadata(deps, postCtx, manifest), {
+    const metadataEntries = await safeRunValue(logger, () => DBOS.runStep(() => generateStepFileMetadata(deps, postCtx, manifest), {
         name: "post-step.generate-file-metadata",
     }), "post-step.metadata", []);
     await emitActivity("generating-summary", "Summarizing step results");
-    const summary = await safeRunValue(() => DBOS.runStep(() => generateStepSummaryAndWrite(deps, postCtx, manifest), {
+    const summary = await safeRunValue(logger, () => DBOS.runStep(() => generateStepSummaryAndWrite(deps, postCtx, manifest), {
         name: "post-step.generate-step-summary",
     }), "post-step.summary", undefined);
     // Lineage attestation (registration + sync) is fail-fast (see the artifact-manifest spec): unlike
@@ -459,10 +475,10 @@ async function runSandboxStepBody(input, deps) {
         stepOutputs = collectStepOutputs(postCtx, postArtifacts);
     }
     catch (err) {
-        console.warn(`[sandbox-step] post-step.collect failed (non-fatal):`, err instanceof Error ? err.message : err);
+        logger.warn("post-step.collect failed (non-fatal)", logger.errorFields(err));
     }
     await emitActivity("indexing", "Indexing outputs for search");
-    await safeRun(() => vectorIndexStepOutputs(deps, postCtx, postArtifacts), "post-step.vector-index");
+    await safeRun(logger, () => vectorIndexStepOutputs(deps, postCtx, postArtifacts), "post-step.vector-index");
     // (9) teardown — destroy sandbox + clear sandbox_ref.
     await DBOS.runStep(() => deps.sandboxClient.teardown(sandbox), { name: "sandbox.teardown" });
     // (10) mark-terminal + emit.
@@ -537,14 +553,17 @@ async function runSandboxStepBody(input, deps) {
  * swallows non-fatal failures — these are reflected in the step summary
  * but do not fail the step itself (synthesis/sync/index can be retried).
  */
-async function safeRun(fn, label) {
+async function safeRun(logger, fn, label) {
     try {
         await fn();
     }
     catch (err) {
         if (err instanceof DBOSErrors.DBOSWorkflowCancelledError)
             throw err;
-        console.warn(`[sandbox-step] ${label} failed (non-fatal):`, err instanceof Error ? err.message : err);
+        // The stage rides as a namespace, not interpolated prose: `label` is what
+        // says WHICH post-step stage degraded, and a reader must be able to filter
+        // on it without parsing the message.
+        logger.named(label).warn("failed (non-fatal)", logger.errorFields(err));
     }
 }
 /**
@@ -552,22 +571,25 @@ async function safeRun(fn, label) {
  * logs and yields `fallback` so the body can thread a safe default downstream
  * instead of aborting the post-step pipeline.
  */
-async function safeRunValue(fn, label, fallback) {
+async function safeRunValue(logger, fn, label, fallback) {
     try {
         return await fn();
     }
     catch (err) {
         if (err instanceof DBOSErrors.DBOSWorkflowCancelledError)
             throw err;
-        console.warn(`[sandbox-step] ${label} failed (non-fatal):`, err instanceof Error ? err.message : err);
+        // The stage rides as a namespace, not interpolated prose: `label` is what
+        // says WHICH post-step stage degraded, and a reader must be able to filter
+        // on it without parsing the message.
+        logger.named(label).warn("failed (non-fatal)", logger.errorFields(err));
         return fallback;
     }
 }
-async function tryTeardown(deps, sandbox) {
+async function tryTeardown(logger, deps, sandbox) {
     try {
         await DBOS.runStep(() => deps.sandboxClient.teardown(sandbox), { name: "sandbox.teardown" });
     }
     catch (err) {
-        console.warn(`[sandbox-step] teardown failed (non-fatal):`, err instanceof Error ? err.message : err);
+        logger.warn("teardown failed (non-fatal)", logger.errorFields(err));
     }
 }

package/dist/workflows/target-assessment/lib/llm-step.d.ts

@@ -23,6 +23,7 @@
  * the caller bumps the attempt counter so the resumed call lands a fresh
  * DBOS cache slot rather than replaying the cancelled prior attempt.
  */
+import type { Logger } from "../../../lib/logger.js";
 import type { AgentChat, ChatRequest, ChatResponse } from "../../../providers/types.js";
 import type { AgentSession } from "../../../auth/types.js";
 /**
@@ -38,6 +39,8 @@ export interface BudgetExceededMarker {
     readonly error: string;
 }
 export interface RunLlmStepOptions {
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
     /** Durable-step name — already attempt-numbered by the caller. */
     readonly stepName: string;
     /** Agent id stamped in the marker for telemetry. */

package/dist/workflows/target-assessment/lib/llm-step.js

@@ -24,6 +24,7 @@
  * DBOS cache slot rather than replaying the cancelled prior attempt.
  */
 import { DBOS } from "@dbos-inc/dbos-sdk";
+import { createNoopLogger } from "../../../lib/console-logger.js";
 import { unwrapOrThrow } from "../../../lib/result.js";
 import { isBudgetExceeded } from "../../../loop/budget-exceeded.js";
 /**
@@ -82,7 +83,8 @@ export async function runLlmStep(opts) {
             await DBOS.runStep(() => DBOS.send(workflowId, marker, BUDGET_EXCEEDED_TOPIC), { name: `${stepName}:notify-budget-exceeded` });
         }
         catch (sendErr) {
-            console.warn(`[ta-llm-step] notify-budget-exceeded send failed (non-fatal): ${sendErr instanceof Error ? sendErr.message : sendErr}`);
+            const logger = (opts.logger ?? createNoopLogger()).named("ta-llm-step");
+            logger.warn("notify-budget-exceeded send failed (non-fatal)", { stepName, ...logger.errorFields(sendErr) });
         }
         return { kind: "budget-exceeded", sentinel: BUDGET_EXCEEDED_SENTINEL };
     }

package/dist/workflows/target-assessment/lib/structured-llm.d.ts

@@ -18,9 +18,12 @@
  */
 import { z } from "zod";
 import type { AgentSession } from "../../../auth/types.js";
+import type { Logger } from "../../../lib/logger.js";
 import type { AgentChat } from "../../../providers/types.js";
 import { BUDGET_EXCEEDED_SENTINEL } from "./llm-step.js";
 export interface StructuredLlmCallOptions<TSchema extends z.ZodType> {
+    /** Operational logging seam, forwarded to `runLlmStep`; omitted falls back to no-op. */
+    readonly logger?: Logger;
     /** Attempt-numbered durable-step name (e.g. `"ta-decision:modulator-triage:0"`). */
     readonly stepName: string;
     /** Agent id stamped on telemetry and billing-gateway provenance. */

package/dist/workflows/target-assessment/lib/structured-llm.js

@@ -78,6 +78,7 @@ export async function structuredLlmCall(opts) {
         toolChoice: { type: "tool", toolName: SUBMIT_TOOL_NAME },
     };
     const result = await runLlmStep({
+        ...(opts.logger ? { logger: opts.logger } : {}),
         stepName: opts.stepName,
         agentId: opts.agentId,
         provider: opts.provider,

package/dist/workflows/target-assessment/phase5-persist.d.ts

@@ -15,6 +15,7 @@
  * in §17 if a harness-native audit pipeline is wired.
  */
 import { z } from "zod";
+import type { Logger } from "../../lib/logger.js";
 import { type DossierV4Body } from "@inflexa-ai/harness/contracts/target-dossier.js";
 import type { Phase2Bundle } from "./steps/phase2-aggregate.js";
 import type { DossierRecommendationStepOutput, LiabilityBulletsStepOutput, SafetyFlagsTrailStepOutput, TranslationalCommentaryStepOutput } from "./synthesis/index.js";
@@ -27,6 +28,8 @@ export declare class DossierDerivedInvariantError extends Error {
     constructor(message: string, cause?: unknown | undefined);
 }
 export interface Phase5PersistInput {
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
     readonly assessmentId: string;
     readonly phase4Dossier: DossierV4Body;
     readonly phase2: Phase2Bundle;

package/dist/workflows/target-assessment/phase5-persist.js

@@ -15,6 +15,7 @@
  * in §17 if a harness-native audit pipeline is wired.
  */
 import { z } from "zod";
+import { createNoopLogger } from "../../lib/console-logger.js";
 import { DossierV5Schema, } from "@inflexa-ai/harness/contracts/target-dossier.js";
 import { getDrugPrimaryTargetUniprots } from "../../tools/lib/chembl-client.js";
 import { deterministicTranslationalCommentary } from "./assemblers/index.js";
@@ -84,7 +85,7 @@ function pickCommentarySeverity(row) {
     }
     return "ok";
 }
-function stampSynthesis(phase4Dossier, syn, phase2) {
+function stampSynthesis(logger, phase4Dossier, syn, phase2) {
     const next = structuredClone(phase4Dossier);
     if (syn.bullets.coverage === "available") {
         next.liability_summary.liability_bullets = syn.bullets.data.bullets.map((b) => ({ text: b.text, rationale: b.rationale, category: b.category }));
@@ -147,7 +148,10 @@ function stampSynthesis(phase4Dossier, syn, phase2) {
         try {
             const audit = validateRecommendationCitations(syn.recommendation.data, next);
             if (audit.citations_unresolved.length > 0) {
-                console.warn(`[phase5-persist] recommendation_audit: ${audit.citations_unresolved.length} unresolved citation(s)`);
+                logger.warn("recommendation_audit: unresolved citation(s)", {
+                    unresolvedCount: audit.citations_unresolved.length,
+                    unresolved: audit.citations_unresolved,
+                });
             }
             next.analytics.recommendation_audit = {
                 coverage: "available",
@@ -388,12 +392,13 @@ async function upgradeDossierToV5(body, phase2) {
  * rejects the final dossier.
  */
 export async function phase5Persist(input) {
+    const logger = (input.logger ?? createNoopLogger()).named("phase5-persist").with({ assessmentId: input.assessmentId });
     // The dossier rides through this function as an untyped working blob; the
     // `as unknown as DossierV{4,5}Body` casts below are version-shim views that
     // let the typed helpers operate on it. None of these casts is load-bearing
     // for soundness: `DossierV5Schema.safeParse(fullDossier)` at the end is the
     // single validation gate, and it throws before anything is returned.
-    let dossier = stampSynthesis(input.phase4Dossier, input.synthesis, input.phase2);
+    let dossier = stampSynthesis(logger, input.phase4Dossier, input.synthesis, input.phase2);
     // Demote organ-claim flagged bullets into coverage_qualifier.unverified_bullets.
     const exec = dossier.executive_recommendation;
     if (exec?.coverage === "available") {

package/dist/workflows/target-assessment/progress.d.ts

@@ -12,6 +12,7 @@
  */
 import type { Pool } from "pg";
 import type { TargetAssessmentPhase, TargetAssessmentProgressEvent } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { Logger } from "../../lib/logger.js";
 /** DBOS stream key the SSE route reads via `DBOS.readStream(wfId, "progress")`. */
 export declare const TA_PROGRESS_STREAM_KEY = "progress";
 export type ProgressPhase = TargetAssessmentPhase;
@@ -35,4 +36,4 @@ export declare const PROGRESS_MESSAGES: Record<ProgressPhase, string>;
  * Best-effort: a DB or stream failure logs and continues — progress
  * emission MUST NOT block the workflow.
  */
-export declare function emitProgress(pool: Pool, assessmentId: string, phase: ProgressPhase): Promise<void>;
+export declare function emitProgress(pool: Pool, logger: Logger, assessmentId: string, phase: ProgressPhase): Promise<void>;

package/dist/workflows/target-assessment/progress.js

@@ -46,7 +46,8 @@ export const PROGRESS_MESSAGES = {
  * Best-effort: a DB or stream failure logs and continues — progress
  * emission MUST NOT block the workflow.
  */
-export async function emitProgress(pool, assessmentId, phase) {
+export async function emitProgress(pool, logger, assessmentId, phase) {
+    const log = logger.named("ta-progress").with({ assessmentId, phase });
     const message = PROGRESS_MESSAGES[phase];
     const percent = PROGRESS_PERCENTS[phase];
     await DBOS.runStep(async () => {
@@ -58,7 +59,7 @@ export async function emitProgress(pool, assessmentId, phase) {
             await DBOS.writeStream(TA_PROGRESS_STREAM_KEY, part);
         }
         catch (err) {
-            console.warn(`[ta-progress] writeStream failed for ${assessmentId} (${phase}): ${err instanceof Error ? err.message : err}`);
+            log.warn("writeStream failed", log.errorFields(err));
         }
         // The "suspended" phase is owned by the terminal handler
         // (`markAssessmentSuspended` already set status + progress text). A
@@ -69,7 +70,7 @@ export async function emitProgress(pool, assessmentId, phase) {
             // emission MUST NOT block the workflow. `updateProgress` returns
             // its DB failure as an `Err`, so handle both branches here.
             (await updateProgress(pool, assessmentId, message, rowStatus)).match(() => { }, (error) => {
-                console.warn(`[ta-progress] updateProgress failed for ${assessmentId} (${phase}): ${describeDbError(error)}`);
+                log.warn("updateProgress failed", { err: describeDbError(error) });
             });
         }
     }, { name: `ta-progress:${phase}` });