@inflexa-ai/harness 0.35.7 → 0.36.0

package/dist/auth/types.d.ts

@@ -24,18 +24,14 @@ export interface Identity {
     readonly user: string;
 }
 /**
- * What the request operates on — a discriminated union owning its resource
- * coordinates (`scopeResource`) and the workload id (`scopeWorkloadId`) used
- * for attribution. `threadId` lives on the analysis variant only.
+ * What the request operates on. It owns its resource coordinates
+ * (`scopeResource`) and the workload id (`scopeWorkloadId`) used for
+ * attribution.
  */
 export type Scope = {
     readonly kind: "analysis";
     readonly analysisId: string;
     readonly threadId?: string;
-} | {
-    readonly kind: "target-assessment";
-    readonly targetAssessmentId: string;
-    readonly billingContextId: string;
 };
 declare const CRED_BRAND: unique symbol;
 /**
@@ -64,15 +60,10 @@ export interface RunFrame {
 }
 /** Canonical resource coordinates a `Scope` resolves to. */
 export interface ResourceCoordinates {
-    readonly resourceType: "analysis" | "billing_context";
+    readonly resourceType: "analysis";
     readonly resourceId: string;
 }
-/**
- * Derive the `{ resourceType, resourceId }` a scope resolves through.
- * Analysis → `{ "analysis", analysisId }`; target-assessment →
- * `{ "billing_context", billingContextId }` (TA resolves billing via the
- * billing-context discriminator until it is a first-class resource).
- */
+/** Derive the `{ resourceType, resourceId }` a scope resolves through: `{ "analysis", analysisId }`. */
 export declare function scopeResource(scope: Scope): ResourceCoordinates;
 /** The value stamped into the workload tag — the workload id for this scope. */
 export declare function scopeWorkloadId(scope: Scope): string;

package/dist/auth/types.js

@@ -19,20 +19,13 @@
  * Neither bundle carries resolved billing headers — billing is resolved
  * lazily at the LLM call site (see `harness/billing/resolver.ts`).
  */
-/**
- * Derive the `{ resourceType, resourceId }` a scope resolves through.
- * Analysis → `{ "analysis", analysisId }`; target-assessment →
- * `{ "billing_context", billingContextId }` (TA resolves billing via the
- * billing-context discriminator until it is a first-class resource).
- */
+/** Derive the `{ resourceType, resourceId }` a scope resolves through: `{ "analysis", analysisId }`. */
 export function scopeResource(scope) {
-    return scope.kind === "analysis"
-        ? { resourceType: "analysis", resourceId: scope.analysisId }
-        : { resourceType: "billing_context", resourceId: scope.billingContextId };
+    return { resourceType: "analysis", resourceId: scope.analysisId };
 }
 /** The value stamped into the workload tag — the workload id for this scope. */
 export function scopeWorkloadId(scope) {
-    return scope.kind === "analysis" ? scope.analysisId : scope.targetAssessmentId;
+    return scope.analysisId;
 }
 /**
  * Derive a child session for a sub-agent call — provenance only. Sets the

package/dist/billing/usage-recorder.d.ts

@@ -36,7 +36,7 @@ export interface LlmUsageRecord {
     readonly agentId: string;
     /** Provenance path from the root agent down to `agentId`. */
     readonly callPath: readonly string[];
-    /** Scope ids as attribution: `analysisId` or `targetAssessmentId`. */
+    /** Scope ids as attribution: `analysisId`. */
     readonly scope: Scope;
     /** Present only for calls made inside a run (the session carries a `RunFrame`). */
     readonly runId?: string;

package/dist/contracts/analogy-report.d.ts

@@ -3,7 +3,7 @@
  * source of truth for the JSON envelope returned to the conversation
  * agent. Both Cortex and the frontend import from this module.
  *
- * Coverage discipline mirrors `target-dossier.ts`: every analogy carries a
+ * Coverage discipline: every analogy carries a
  * `coverage` discriminator. Only the extraction phase is allowed to throw;
  * search-phase failures surface via `coverage: "search_failed" |
  * "queried_no_data" | "not_loaded"`.

package/dist/contracts/analogy-report.js

@@ -3,7 +3,7 @@
  * source of truth for the JSON envelope returned to the conversation
  * agent. Both Cortex and the frontend import from this module.
  *
- * Coverage discipline mirrors `target-dossier.ts`: every analogy carries a
+ * Coverage discipline: every analogy carries a
  * `coverage` discriminator. Only the extraction phase is allowed to throw;
  * search-phase failures surface via `coverage: "search_failed" |
  * "queried_no_data" | "not_loaded"`.

package/dist/contracts/chat-parts.d.ts

@@ -211,9 +211,8 @@ export interface StepSummaryPart {
  * absent or zeroed figure. Per-call granularity is the usage-record ledger's
  * job, never this part's.
  *
- * Scoped to analysis runs. Workflows without step parts (target assessment,
- * ephemeral runs, data profiling) reach the ledger through the recorder seam and
- * carry no usage part.
+ * Scoped to analysis runs. Workflows without step parts (ephemeral runs, data
+ * profiling) reach the ledger through the recorder seam and carry no usage part.
  */
 export interface StepUsagePart {
     type: "data-step-usage";

package/dist/contracts/index.d.ts

@@ -14,8 +14,4 @@ export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part
 export type { CortexChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";
 export type { AnalogyCoverage, AnalogyReport, AnalogyReportError, AnalogicalReasonerOutput } from "./analogy-report.js";
-export { CoverageSchema, RowCoverageSchema, EntitySchema, ClaimSupportSchema, ClaimEvidenceSchema, LiabilityBulletSchema, LiabilitySummarySchema, TractabilitySchema, IndicationsSchema, DrugInteractionsSchema, ClinicalTrialAttributionSchema, ClinicalDevelopmentSchema, OrganRiskRowSchema, OffTargetRowSchema, OffTargetPanelSchema, RegulatoryActionRowSchema, SafetyFlagSchema, SafetyProfileSchema, OffTissueRowSchema, OffTissueRiskSchema, ReferenceBiologyShape, EvidenceConflictsSchema, EvidenceTimelineSchema, TranslationalChainSchema, AdditionalEvidenceSchema, DiscoveryTrialsSchema, QualityGateStatusSchema, QualityGatesSchema, DerivedSchema, DossierSchema, DossierBodySchema, isDossier, dossierJsonSchema, SECTION_BLURBS, TargetAssessmentPhaseSchema, TargetAssessmentProgressEventSchema, } from "./target-dossier.js";
-export type { Coverage, RowCoverage, Entity, EvidenceItem, ClaimSupport, ClaimEvidence, LiabilityBullet, LiabilitySummary, TractabilitySection, ClinicalTrialAttribution, ClinicalTrialRow, ClinicalDevelopment, FailedTrialRow, TrialOutcomeRow, OrganRiskRow, OffTargetRow, RegulatoryActionRow, SafetyFlag, SafetyProfile, OffTissueRow, QualityGateStatus, QualityGates, Derived, Dossier, DossierBody, SectionBlurbKey, TargetAssessmentPhase, TargetAssessmentProgressEvent, } from "./target-dossier.js";
-export { TargetAssessmentStatusSchema, TargetAssessmentErrorSchema, TargetAssessmentListRowSchema, TargetAssessmentRowSchema, } from "./target-assessment-row.js";
-export type { TargetAssessmentStatus, TargetAssessmentError, TargetAssessmentListRow, TargetAssessmentRow } from "./target-assessment-row.js";
 export { buildReportSessionUrl, reportSessionResourceId } from "./content-url.js";

package/dist/contracts/index.js

@@ -4,6 +4,4 @@ export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
 export { DIMENSION_CATEGORIES, DIMENSION_CATEGORY_IDS, DIMENSION_PROBE_IDS, DIMENSION_PROBES, GROUP_CATEGORIES, GROUP_CATEGORY_IDS, GROUP_ROLE_IDS, GROUP_ROLES, PROBE_OUTCOME_IDS, dimensionCategoryEntry, dimensionScope, groupCategoryEntry, } from "./profile-vocabulary.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";
-export { CoverageSchema, RowCoverageSchema, EntitySchema, ClaimSupportSchema, ClaimEvidenceSchema, LiabilityBulletSchema, LiabilitySummarySchema, TractabilitySchema, IndicationsSchema, DrugInteractionsSchema, ClinicalTrialAttributionSchema, ClinicalDevelopmentSchema, OrganRiskRowSchema, OffTargetRowSchema, OffTargetPanelSchema, RegulatoryActionRowSchema, SafetyFlagSchema, SafetyProfileSchema, OffTissueRowSchema, OffTissueRiskSchema, ReferenceBiologyShape, EvidenceConflictsSchema, EvidenceTimelineSchema, TranslationalChainSchema, AdditionalEvidenceSchema, DiscoveryTrialsSchema, QualityGateStatusSchema, QualityGatesSchema, DerivedSchema, DossierSchema, DossierBodySchema, isDossier, dossierJsonSchema, SECTION_BLURBS, TargetAssessmentPhaseSchema, TargetAssessmentProgressEventSchema, } from "./target-dossier.js";
-export { TargetAssessmentStatusSchema, TargetAssessmentErrorSchema, TargetAssessmentListRowSchema, TargetAssessmentRowSchema, } from "./target-assessment-row.js";
 export { buildReportSessionUrl, reportSessionResourceId } from "./content-url.js";

package/dist/index.d.ts

@@ -156,13 +156,6 @@ export { registerExecuteAnalysis } from "./workflows/execute-analysis.js";
 export type { ExecuteAnalysisDeps, ExecuteAnalysisInput, ExecuteAnalysisResult, RunObservation, RunStepObservation, StepRuntimeStatus, } from "./workflows/execute-analysis.js";
 export { registerSandboxStep } from "./workflows/sandbox-step.js";
 export type { SandboxStepDeps, SandboxStepInput, SandboxStepResult, SandboxAgentBuildContext } from "./workflows/sandbox-step.js";
-export { DEFAULT_CLAIM_INVESTIGATION_CONFIG } from "./workflows/target-assessment/investigation/index.js";
-export type { ClaimInvestigationConfig } from "./workflows/target-assessment/investigation/index.js";
-export { insertAssessment, getAssessment, updateProgress, listAssessmentsByOrg } from "./state/target-assessments.js";
-export type { InsertAssessmentInput, ListAssessmentsOptions } from "./state/target-assessments.js";
-export type { TargetAssessmentRow, TargetAssessmentListRow, TargetAssessmentStatus, TargetAssessmentError } from "./state/target-assessments.js";
-export { createTargetAssessmentProgressStream } from "./workflows/target-assessment/progress-stream.js";
-export type { TargetAssessmentProgressStream, TargetAssessmentProgressStreamDeps, TargetAssessmentProgressHandler, TargetAssessmentProgressSubscribeOptions, } from "./workflows/target-assessment/progress-stream.js";
 export { createRunEventStream } from "./execution/run-event-stream.js";
 export type { RunEventStream, RunEventStreamDeps, RunEventSubscribeOptions, RunEventPartHandler } from "./execution/run-event-stream.js";
 export { createSandboxAgents, SANDBOX_AGENT_META } from "./agents/sandbox/index.js";

package/dist/index.js

@@ -271,27 +271,6 @@ export { ExecEventMessageSchema } from "./sandbox/types.js";
 // these, but an embedder running only the run engine registers them directly.
 export { registerExecuteAnalysis } from "./workflows/execute-analysis.js";
 export { registerSandboxStep } from "./workflows/sandbox-step.js";
-// Target assessment — the bounds its claim-investigation phase runs under. An
-// embedder wiring `executeTargetAssessment` sets these at its composition root;
-// the dossier reports whichever values were in force.
-export { DEFAULT_CLAIM_INVESTIGATION_CONFIG } from "./workflows/target-assessment/investigation/index.js";
-// The row surface of `cortex_target_assessments`: the intake write an embedder's
-// trigger route makes, the two reads its detail and list routes make, and the
-// progress write. The row types ride with them — `getAssessment` and
-// `listAssessmentsByOrg` hand back values an embedder cannot hold without naming,
-// and `TargetAssessmentStatus` is what a host switches on to render one. The
-// terminal writers (`setDossier`, `markFailed`, `markAssessmentSuspended`,
-// `markAssessmentRunning`, `softDeleteAssessment`) stay off the front door: the
-// workflow's own terminal path owns them, and an embedder calling one races the
-// state the workflow is about to write.
-export { insertAssessment, getAssessment, updateProgress, listAssessmentsByOrg } from "./state/target-assessments.js";
-// The read side of a target assessment's progress stream. `emitProgress` writes
-// one part per phase and the workflow owns that write; this is the only way to
-// read it back without reaching for the durability engine, which is exactly what
-// an embedder rendering a progress bar would otherwise have to do. One stream per
-// assessment (`workflowID === assessmentId`), so it needs no pool — unlike the
-// run-event seam below, which fans in a parent and its children.
-export { createTargetAssessmentProgressStream } from "./workflows/target-assessment/progress-stream.js";
 // Run-event read seam — the fine-grained durable channel beside `observeRun`.
 // The two are a deliberate pair, not a duplication: `observeRun` is the coarse,
 // in-process run/step snapshot a workflow hands its host synchronously, and it

package/dist/lib/metrics.d.ts

@@ -35,7 +35,7 @@ import type { StepExecutionStatus } from "../state/schema.js";
 /** Terminal status of a run. A budget pause records as `canceled`, the same as the run ledger. */
 export type RunOutcome = "completed" | "partial" | "failed" | "canceled";
 /** The workflow family a run belongs to. */
-export type RunWorkflow = "analysis" | "target_assessment" | "data_profile";
+export type RunWorkflow = "analysis" | "data_profile";
 /** Terminal status of an executed step. A blocker is a failure to deliver, so `blocked` maps here to `failed`. */
 export type StepOutcome = "completed" | "failed" | "canceled";
 /**

package/dist/lib/otel-spans.d.ts

@@ -48,8 +48,6 @@ export declare const ATTR_INFLEXA_TOOL_USE_ID = "inflexa.tool_use_id";
 export declare const ATTR_INFLEXA_EXEC_ID = "inflexa.exec_id";
 /** The 1-based attempt counter of a sandbox poll, pull, or liveness-probe step. */
 export declare const ATTR_INFLEXA_ATTEMPT = "inflexa.attempt";
-/** The per-item key (a ChEMBL or NCT id) of a target-assessment fan-out step. */
-export declare const ATTR_INFLEXA_FANOUT_KEY = "inflexa.fanout_key";
 /**
  * Rename the DBOS span of the step that is running to `name` and put its id
  * in `attributes`. Call it as the first statement of a step body whose DBOS

package/dist/lib/otel-spans.js

@@ -71,8 +71,6 @@ export const ATTR_INFLEXA_TOOL_USE_ID = "inflexa.tool_use_id";
 export const ATTR_INFLEXA_EXEC_ID = "inflexa.exec_id";
 /** The 1-based attempt counter of a sandbox poll, pull, or liveness-probe step. */
 export const ATTR_INFLEXA_ATTEMPT = "inflexa.attempt";
-/** The per-item key (a ChEMBL or NCT id) of a target-assessment fan-out step. */
-export const ATTR_INFLEXA_FANOUT_KEY = "inflexa.fanout_key";
 /**
  * Rename the DBOS span of the step that is running to `name` and put its id
  * in `attributes`. Call it as the first statement of a step body whose DBOS

package/dist/loop/genai-spans.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OpenTelemetry GenAI spans for the agent loop: `invoke_agent` around a run of
+ * `runAgent`, and `execute_tool` around each tool call that it dispatches. The AI
+ * SDK traces the model calls (`providers/ai-sdk.ts`). It never sees the loop or
+ * the tools, because the harness runs both itself.
+ */
+import type { ToolCallPart } from "ai";
+import type { AgentSession } from "../auth/types.js";
+import type { ToolOutcome } from "./tool-outcome.js";
+interface AgentRun {
+    readonly finish: {
+        readonly reason: string;
+        readonly cappedOut: boolean;
+    };
+}
+/** Run one agent loop under an `invoke_agent` span. */
+export declare function traceAgentRun<T extends AgentRun>(agentName: string, session: AgentSession, run: () => Promise<T>): Promise<T>;
+/** Run one tool call under an `execute_tool` span that records how the call ended. */
+export declare function traceToolCall<T>(call: Pick<ToolCallPart, "toolName" | "toolCallId">, run: () => Promise<T>, outcomeOf: (value: T) => ToolOutcome): Promise<T>;
+export {};

package/dist/loop/genai-spans.js

@@ -0,0 +1,53 @@
+/**
+ * OpenTelemetry GenAI spans for the agent loop: `invoke_agent` around a run of
+ * `runAgent`, and `execute_tool` around each tool call that it dispatches. The AI
+ * SDK traces the model calls (`providers/ai-sdk.ts`). It never sees the loop or
+ * the tools, because the harness runs both itself.
+ */
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+/** Run one agent loop under an `invoke_agent` span. */
+export function traceAgentRun(agentName, session, run) {
+    const attributes = { "gen_ai.operation.name": "invoke_agent", "gen_ai.agent.name": agentName, ...runFrameAttributes(session) };
+    return withSpan(`invoke_agent ${agentName}`, attributes, async (span) => {
+        const result = await run();
+        span.setAttributes({ "gen_ai.response.finish_reasons": [result.finish.reason], "inflexa.agent.capped_out": result.finish.cappedOut });
+        return result;
+    });
+}
+/** Run one tool call under an `execute_tool` span that records how the call ended. */
+export function traceToolCall(call, run, outcomeOf) {
+    const attributes = { "gen_ai.operation.name": "execute_tool", "gen_ai.tool.name": call.toolName, "gen_ai.tool.call.id": call.toolCallId };
+    return withSpan(`execute_tool ${call.toolName}`, attributes, async (span) => {
+        const value = await run();
+        const outcome = outcomeOf(value);
+        span.setAttribute("inflexa.tool.outcome", outcome);
+        if (outcome === "error")
+            span.setStatus({ code: SpanStatusCode.ERROR });
+        return value;
+    });
+}
+function withSpan(name, attributes, run) {
+    return trace.getTracer("@inflexa-ai/harness").startActiveSpan(name, { attributes }, async (span) => {
+        try {
+            return await run(span);
+        }
+        catch (err) {
+            // A cancellation is the caller's decision, not a failure.
+            const cancelled = err instanceof Error && err.name === "AbortError";
+            if (!cancelled) {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+                if (err instanceof Error)
+                    span.recordException(err);
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    });
+}
+function runFrameAttributes({ runFrame }) {
+    if (runFrame === undefined)
+        return {};
+    return { "inflexa.run_id": runFrame.runId, ...(runFrame.stepId === undefined ? {} : { "inflexa.step_id": runFrame.stepId }) };
+}

package/dist/loop/run-agent.d.ts

@@ -70,7 +70,7 @@ export interface RunAgentOptions {
      *
      * The policy lives here, on the run, rather than on the provider, precisely
      * so it applies to loops and *not* to the one-shot LLM calls made elsewhere
-     * (report generation, target-assessment steps): those would pay the
+     * (report generation): those would pay the
      * cache-write premium for a cache nothing ever reads back.
      */
     readonly promptCache?: PromptCachePolicy;

package/dist/loop/run-agent.js

@@ -13,6 +13,7 @@ import { DEFAULT_REASONING } from "../providers/reasoning.js";
 import { resultStep } from "./run-step.js";
 import { AskRejectedError, UnavailableAsk } from "../tools/approval/contract.js";
 import { isToolError, readToolResultImages } from "../tools/define-tool.js";
+import { traceAgentRun, traceToolCall } from "./genai-spans.js";
 import { addChatUsage, hasReportedUsage, recordAgentRun } from "./metrics.js";
 import { computeDetail, computeResultDetail } from "./tool-detail.js";
 import { toolOutcomeForOutputType } from "./tool-outcome.js";
@@ -22,7 +23,10 @@ export const DEFAULT_STEP_NAME_FORMATTER = {
     llm: (i) => `llm-${i}`,
     tool: (name, id) => `tool-${name}-${id}`,
 };
-export async function runAgent(agent, initial, session, opts) {
+export function runAgent(agent, initial, session, opts) {
+    return traceAgentRun(agent.id, session, () => runAgentLoop(agent, initial, session, opts));
+}
+async function runAgentLoop(agent, initial, session, opts) {
     const { provider, signal, emit, runStep } = opts;
     const formatStepName = opts.formatStepName ?? DEFAULT_STEP_NAME_FORMATTER;
     const configuredFatalLoopError = opts.isFatalLoopError ?? (() => false);
@@ -524,6 +528,7 @@ function appendDeferredImages(messages, results, deferredImages) {
  * is genuinely fast. A bracket inside the step would report a body that did not run.
  */
 async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, runStep, toolStepName, encoding) {
+    const dispatch = (tu) => traceToolCall(tu, () => dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding), (dispatched) => outcomeOf(dispatched.result));
     const results = new Array(toolUses.length);
     // The array starts with holes, which read as `undefined`. The element type
     // says so, thus it agrees with what `settleRound` accepts. Every index is in
@@ -550,7 +555,7 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
         const stepName = toolStepName(tu.toolName, tu.toolCallId);
         return runStep(stepName, () => {
             stableSpan(stepName, `tool:${tu.toolName}`, { [ATTR_INFLEXA_TOOL_USE_ID]: tu.toolCallId });
-            return dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+            return dispatch(tu);
         }).then((settled) => {
             durations[idx] = elapsedMs(startedAt);
             const dispatched = readDispatchedStep(settled);
@@ -561,7 +566,7 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
     }));
     for (const { tu, idx } of workflowTools) {
         const startedAt = performance.now();
-        const dispatched = await dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+        const dispatched = await dispatch(tu);
         results[idx] = dispatched.result;
         if (dispatched.detail !== undefined)
             resultDetails[idx] = dispatched.detail;
@@ -569,7 +574,7 @@ async function dispatchTools(toolUses, toolsById, toolCtx, isFatalLoopError, run
     }
     for (const { tu, idx } of inlineTools) {
         const startedAt = performance.now();
-        const dispatched = await dispatchTool(tu, toolsById, toolCtx(tu), isFatalLoopError, encoding);
+        const dispatched = await dispatch(tu);
         results[idx] = dispatched.result;
         if (dispatched.detail !== undefined)
             resultDetails[idx] = dispatched.detail;

package/dist/providers/ai-sdk.js

@@ -2,6 +2,7 @@ import { streamText, wrapLanguageModel, } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { OpenTelemetry } from "@ai-sdk/otel";
 import { APICallError } from "@ai-sdk/provider";
 import { retryWithExponentialBackoff } from "@ai-sdk/provider-utils";
 import { ResultAsync, err, ok } from "neverthrow";
@@ -431,6 +432,11 @@ export function createAiSdkProvider(deps) {
     const maxRetries = deps.maxRetries ?? RETRY_MAX_RETRIES;
     const requestTimeoutMs = deps.requestTimeoutMs;
     const requestedModelId = requestedModelIdOf(deps.model);
+    // Each model call emits OpenTelemetry GenAI spans through the AI SDK, with no
+    // prompt or completion text on them. The integration rides on each call
+    // instead of the global registry, so the harness never traces the embedder's
+    // own AI SDK calls.
+    const telemetry = { integrations: new OpenTelemetry(), recordInputs: false, recordOutputs: false };
     routeSdkWarningsTo(logger);
     /**
      * Record a call that the envelope gave up on.
@@ -484,6 +490,7 @@ export function createAiSdkProvider(deps) {
                         maxRetries: 0,
                         headers,
                         abortSignal: signal,
+                        telemetry,
                         // `firstChunkMs` bounds the wait for the first content chunk,
                         // and `chunkMs` bounds each later gap. Thus each silent interval
                         // carries the one configured bound, and a turn that writes
@@ -560,6 +567,7 @@ export function createAiSdkProvider(deps) {
                     maxRetries: 0,
                     headers,
                     abortSignal: signal,
+                    telemetry,
                     // The fetch guard bounds the wait until the headers. Past the
                     // headers the SDK owns two bounds: `firstChunkMs` covers the wait
                     // for the first content chunk, and `chunkMs` covers each later

package/dist/runtime/assemble.d.ts

@@ -25,7 +25,6 @@ import { type AcquireEyes } from "../lib/eyes.js";
 import type { ThreadType } from "../memory/thread-store.js";
 import { type ExecuteAnalysisDeps, type ExecuteAnalysisInput, type ExecuteAnalysisResult } from "../workflows/execute-analysis.js";
 import { type SandboxStepDeps, type SandboxStepInput, type SandboxStepResult } from "../workflows/sandbox-step.js";
-import { type ExecuteTargetAssessmentDeps, type ExecuteTargetAssessmentInput, type ExecuteTargetAssessmentResult } from "../workflows/execute-target-assessment.js";
 import { type DataProfileDeps, type DataProfileWorkflowInput } from "../tasks/data-profile.js";
 import { type ExtractValuesResult, type ExtractValuesWorkflowInput } from "../tasks/extract-values.js";
 import type { DeriveTableExecInput } from "../tools/report-session/derive-table.js";
@@ -54,14 +53,12 @@ export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxSt
 export interface CoreWorkflowDeps {
     readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver">;
     readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "citationResolver">;
-    readonly executeTargetAssessment: Omit<ExecuteTargetAssessmentDeps, "usageRecorder">;
     readonly dataProfile: Omit<DataProfileDeps, "usageRecorder">;
 }
 /** The registered, callable workflow handles. */
 export interface RegisteredWorkflows {
     readonly executeAnalysis: (input: ExecuteAnalysisInput) => Promise<ExecuteAnalysisResult>;
     readonly sandboxStep: SandboxStepCallable;
-    readonly executeTargetAssessment: (input: ExecuteTargetAssessmentInput) => Promise<ExecuteTargetAssessmentResult>;
     readonly dataProfile: (input: DataProfileWorkflowInput) => Promise<void>;
     readonly extractValues: (input: ExtractValuesWorkflowInput) => Promise<ExtractValuesResult>;
     readonly deriveTableExec: (input: DeriveTableExecInput) => Promise<ExecResult>;

package/dist/runtime/assemble.js

@@ -23,7 +23,6 @@ import { hasBrowserUrl } from "../lib/chrome.js";
 import { createStaticEyes } from "../lib/eyes.js";
 import { registerExecuteAnalysis } from "../workflows/execute-analysis.js";
 import { registerSandboxStep } from "../workflows/sandbox-step.js";
-import { registerExecuteTargetAssessment, } from "../workflows/execute-target-assessment.js";
 import { registerDataProfileWorkflow } from "../tasks/data-profile.js";
 import { bindExtractionTrigger, createExtractionArm, registerExtractValuesWorkflow, } from "../tasks/extract-values.js";
 import { registerDeriveTableExecWorkflow, triggerDeriveTableExec } from "../tasks/derive-table-exec.js";
@@ -86,7 +85,6 @@ export function assembleCoreRuntime(deps) {
     });
     const sandboxStep = registerSandboxStep({ ...wf.sandboxStep, citationResolver, usageRecorder });
     const executeAnalysis = registerExecuteAnalysis({ ...wf.buildExecuteAnalysis(sandboxStep), citationResolver, usageRecorder });
-    const executeTargetAssessment = registerExecuteTargetAssessment({ ...wf.executeTargetAssessment, usageRecorder });
     const dataProfile = registerDataProfileWorkflow({ ...wf.dataProfile, usageRecorder });
     // The extraction workflow shares the profile's sandbox and authorization rails, thus it draws the same
     // three seams from the profile deps. The report resolver factory binds the extraction arm over this
@@ -196,7 +194,6 @@ export function assembleCoreRuntime(deps) {
         workflows: {
             executeAnalysis,
             sandboxStep,
-            executeTargetAssessment,
             dataProfile,
             extractValues,
             deriveTableExec,

package/dist/state/index.d.ts

@@ -27,5 +27,3 @@ export { createAnalysisPurge } from "./purge-analysis.js";
 export type { AnalysisPurge, AnalysisPurgeDeps, AnalysisPurgeOutcome } from "./purge-analysis.js";
 export { AnalysisStateRowSchema, ArtifactRole, ArtifactRowSchema, RunStatus, StepExecutionStatus, SynthesisStatus, CortexRunRowSchema, StepExecutionRowSchema, CortexPlanRowSchema, } from "./schema.js";
 export type { AnalysisStateRow, ArtifactRow, CortexRunRow, StepExecutionRow, CortexPlanRow } from "./schema.js";
-export { insertAssessment, updateProgress, setDossier, markFailed, getAssessment, listAssessmentsByOrg, softDeleteAssessment, TargetAssessmentStatusSchema, TargetAssessmentErrorSchema, TargetAssessmentRowSchema, } from "./target-assessments.js";
-export type { TargetAssessmentStatus, TargetAssessmentRow, TargetAssessmentError, InsertAssessmentInput, ListAssessmentsOptions, } from "./target-assessments.js";

package/dist/state/index.js

@@ -20,4 +20,3 @@ export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfile
 // alone, with the workflow ledger behind an injected seam.
 export { createAnalysisPurge } from "./purge-analysis.js";
 export { AnalysisStateRowSchema, ArtifactRole, ArtifactRowSchema, RunStatus, StepExecutionStatus, SynthesisStatus, CortexRunRowSchema, StepExecutionRowSchema, CortexPlanRowSchema, } from "./schema.js";
-export { insertAssessment, updateProgress, setDossier, markFailed, getAssessment, listAssessmentsByOrg, softDeleteAssessment, TargetAssessmentStatusSchema, TargetAssessmentErrorSchema, TargetAssessmentRowSchema, } from "./target-assessments.js";

package/dist/state/init.js

@@ -199,65 +199,6 @@ CREATE TABLE IF NOT EXISTS cortex_report_session_state (
 CREATE INDEX IF NOT EXISTS idx_cortex_report_session_state_analysis
   ON cortex_report_session_state(analysis_id);
 
--- Target assessments — organization-scoped, snapshot-style target dossiers.
--- Independent of analyses, projects, runs, and chat threads. The full
--- dossier is persisted as JSONB on the row, no separate artifacts table.
-CREATE TABLE IF NOT EXISTS cortex_target_assessments (
-  id                 UUID PRIMARY KEY,
-  organization_id    TEXT NOT NULL,
-  target_id          TEXT NOT NULL,
-  target_label       TEXT NOT NULL,
-  goal               TEXT,
-  status             TEXT NOT NULL,
-  progress           TEXT,
-  dossier            JSONB,
-  billing_context_id TEXT NOT NULL,
-  error              JSONB,
-  requested_by       TEXT NOT NULL,
-  workflow_run_id    TEXT,
-  created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  completed_at       TIMESTAMPTZ
-);
-
-ALTER TABLE cortex_target_assessments
-  ADD COLUMN IF NOT EXISTS workflow_run_id TEXT;
-
--- DBOS workflow id for the executeTargetAssessment workflow. For DBOS-shaped
--- rows, workflow_id = assessmentId (the workflowID passed to DBOS.startWorkflow).
--- Nullable so older rows tolerate NULL -- new rows always write
--- workflow_id alongside the row insert.
-ALTER TABLE cortex_target_assessments
-  ADD COLUMN IF NOT EXISTS workflow_id TEXT;
-
-CREATE INDEX IF NOT EXISTS idx_cortex_target_assessments_workflow_id
-  ON cortex_target_assessments(workflow_id);
-
-CREATE INDEX IF NOT EXISTS idx_cortex_target_assessments_org_created
-  ON cortex_target_assessments(organization_id, created_at DESC);
-
-CREATE INDEX IF NOT EXISTS idx_cortex_target_assessments_org_target_created
-  ON cortex_target_assessments(organization_id, target_id, created_at DESC);
-
--- Per-row clinical-consequence annotations for off-target hits, produced by
--- a focused LLM annotator. Cached by (primary_target_gene, off_target_key)
--- so repeat assessments of the same target reuse prior work and avoid
--- per-run LLM cost.
---
--- off_target_key is the ChEMBL ID when present, else the (trimmed,
--- lowercased) off-target name. Composite primary key prevents duplicate
--- annotations.
-CREATE TABLE IF NOT EXISTS cortex_off_target_annotations (
-  primary_target_gene  TEXT NOT NULL,
-  off_target_key       TEXT NOT NULL,
-  off_target_name      TEXT NOT NULL,
-  clinical_consequence TEXT NOT NULL,
-  provenance           TEXT,
-  model                TEXT NOT NULL,
-  created_at           TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  PRIMARY KEY (primary_target_gene, off_target_key)
-);
-
 -- Regulatory guidance corpus — pre-indexed FDA CDER, FDA CBER, and ICH
 -- guidance documents. Written/refreshed via tasks/refresh-regulatory-corpus.ts
 -- and searched (top-K cosine) via lib/regulatory-corpus.ts. No synthesis tool
@@ -684,7 +625,7 @@ export async function initCortexState(pool, injected) {
             }
             // No boot-time orphan sweep on cortex_runs / cortex_step_executions.
             // Every running row is backed by a DBOS workflow (executeAnalysis,
-            // executeTargetAssessment, resume entry); DBOS recovery is the
+            // resume entry); DBOS recovery is the
             // substitute — each pod has a stable executorID (StatefulSet pod name)
             // and runs `recoverPendingWorkflows` for its own ID at launch (ADR
             // 0012). The workflow body owns the terminal transition on cortex_runs;

package/dist/state/purge-analysis.d.ts

@@ -28,8 +28,7 @@
  *
  * What it does not reach, so that absent coverage is never read as delivered:
  * scheduled operational workflows (they belong to no analysis and accumulate
- * independently of any purge), target assessments and their annotations (a
- * separate top-level entity), the shared regulatory corpus, `messages` rows whose
+ * independently of any purge), the shared regulatory corpus, `messages` rows whose
  * thread row is already gone (nothing attributes them to an analysis), and
  * workspace files on disk (the embedder owns their disposal).
  */

package/dist/state/purge-analysis.js

@@ -28,8 +28,7 @@
  *
  * What it does not reach, so that absent coverage is never read as delivered:
  * scheduled operational workflows (they belong to no analysis and accumulate
- * independently of any purge), target assessments and their annotations (a
- * separate top-level entity), the shared regulatory corpus, `messages` rows whose
+ * independently of any purge), the shared regulatory corpus, `messages` rows whose
  * thread row is already gone (nothing attributes them to an analysis), and
  * workspace files on disk (the embedder owns their disposal).
  */

package/dist/tasks/regulatory-corpus-boot-refresh.js

@@ -79,7 +79,7 @@ export async function maybeKickOffRegulatoryCorpusRefresh(deps) {
         return "skipped-fresh";
     }
     // Corpus is stale — resolve the maintenance embedder. System-scoped
-    // maintenance work has no analysis/target-assessment to bill against, so
+    // maintenance work has no analysis to bill against, so
     // we route directly to api.openai.com on a dedicated key. Never the
     // billing-gateway-routed workspace embedder, which would emit unattributed calls
     // and flood the boot log via `billing-fetch-patch`.

package/dist/tools/bio/gene-preclinical-profile.d.ts

@@ -12,9 +12,7 @@
  *
  * No source caps its own output: Bgee returns every annotated tissue per
  * species, IMPC every significant phenotype term, and Monarch every curated
- * HPO annotation, so each half is trimmed here rather than in the clients — the
- * target-assessment collectors read the same clients and legitimately want full
- * fidelity for the dossier.
+ * HPO annotation, so each half is trimmed here rather than in the clients.
  */
 import { type SupportedSpecies, type TissueRow } from "../lib/bgee-client.js";
 import { type MpTerm, type ViabilityCall, type ViabilityCategory } from "../lib/impc-client.js";

package/dist/tools/bio/gene-preclinical-profile.js

@@ -12,9 +12,7 @@
  *
  * No source caps its own output: Bgee returns every annotated tissue per
  * species, IMPC every significant phenotype term, and Monarch every curated
- * HPO annotation, so each half is trimmed here rather than in the clients — the
- * target-assessment collectors read the same clients and legitimately want full
- * fidelity for the dossier.
+ * HPO annotation, so each half is trimmed here rather than in the clients.
  */
 import { ok } from "neverthrow";
 import { z } from "zod";

package/dist/tools/lib/chembl-client.d.ts

@@ -1,7 +1,7 @@
 /**
  * Pure async client functions for the ChEMBL REST API.
  *
- * Used directly by target-assessment workflow steps and by tool wrappers.
+ * Used by tool wrappers.
  *
  * Absence policy: ChEMBL sends an explicit `null` for an absent value, and it
  * never omits the key. Thus a maybe-absent field carries `.nullable()`, not
@@ -234,8 +234,5 @@ export declare function getMoleculeInChIKey(moleculeChemblId: string): Promise<s
  * Resolve a drug's mechanism-of-action targets to UniProt accessions.
  * Returns deduplicated accessions across all mechanism rows.
  * Empty array on no mechanism, missing target, or non-protein target.
- *
- * Used by target-identity-filter to detect off-target trials (e.g., a
- * trial of a CALCRL drug being surfaced under a CALCR assessment).
  */
 export declare function getDrugPrimaryTargetUniprots(moleculeChemblId: string): Promise<string[]>;

package/dist/tools/lib/chembl-client.js

@@ -1,7 +1,7 @@
 /**
  * Pure async client functions for the ChEMBL REST API.
  *
- * Used directly by target-assessment workflow steps and by tool wrappers.
+ * Used by tool wrappers.
  *
  * Absence policy: ChEMBL sends an explicit `null` for an absent value, and it
  * never omits the key. Thus a maybe-absent field carries `.nullable()`, not
@@ -673,9 +673,6 @@ export async function getMoleculeInChIKey(moleculeChemblId) {
  * Resolve a drug's mechanism-of-action targets to UniProt accessions.
  * Returns deduplicated accessions across all mechanism rows.
  * Empty array on no mechanism, missing target, or non-protein target.
- *
- * Used by target-identity-filter to detect off-target trials (e.g., a
- * trial of a CALCRL drug being surfaced under a CALCR assessment).
  */
 export async function getDrugPrimaryTargetUniprots(moleculeChemblId) {
     const mechRes = await apiFetchValidated(`${CHEMBL_BASE}/mechanism.json?molecule_chembl_id=${encodeURIComponent(moleculeChemblId)}&limit=20`, MechanismsResponseSchema, { headers: HEADERS });

package/dist/tools/lib/clinical-benchmarks-client.d.ts

@@ -29,7 +29,7 @@ export declare function inferTherapeuticArea(indicationLabels: string[]): string
  * `source` field discloses whether the fallback was used.
  */
 export declare function getBenchmarks(therapeuticArea: string | null): BenchmarkResult;
-/** Return the dataset's metadata for transparency in the dossier. */
+/** Return the dataset's metadata for transparency. */
 export declare function getDatasetAttribution(): {
     data_version: string;
     data_window: string;