@inflexa-ai/harness 0.35.8 → 0.36.1

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

@@ -3,6 +3,10 @@
  * `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.
+ *
+ * An `execute_tool` span is ERROR when our code fails the call. A failure that a
+ * tool returns as data, for example a sandbox command that exits non-zero, is
+ * normal iteration of the agent, and its span stays OK.
  */
 import type { ToolCallPart } from "ai";
 import type { AgentSession } from "../auth/types.js";
@@ -17,4 +21,14 @@ interface AgentRun {
 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>;
+/**
+ * Record an exception that a tool threw on the active `execute_tool` span.
+ * `error.type` is the code of the error when it has one, else its name.
+ */
+export declare function recordToolException(err: Error): void;
+/**
+ * Label a tool failure that is not an exception on the active `execute_tool`
+ * span. `message` is text that our tool wrote, never text from the model.
+ */
+export declare function labelToolFailure(type: string, message?: string): void;
 export {};

package/dist/loop/genai-spans.js

@@ -3,6 +3,10 @@
  * `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.
+ *
+ * An `execute_tool` span is ERROR when our code fails the call. A failure that a
+ * tool returns as data, for example a sandbox command that exits non-zero, is
+ * normal iteration of the agent, and its span stays OK.
  */
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 /** Run one agent loop under an `invoke_agent` span. */
@@ -26,6 +30,37 @@ export function traceToolCall(call, run, outcomeOf) {
         return value;
     });
 }
+/** The cap of `inflexa.tool.error`, in characters. */
+const TOOL_ERROR_MAX_CHARS = 1_000;
+/**
+ * Record an exception that a tool threw on the active `execute_tool` span.
+ * `error.type` is the code of the error when it has one, else its name.
+ */
+export function recordToolException(err) {
+    const span = trace.getActiveSpan();
+    if (span === undefined)
+        return;
+    span.recordException(err);
+    span.setAttribute("error.type", errorTypeOf(err));
+}
+/**
+ * Label a tool failure that is not an exception on the active `execute_tool`
+ * span. `message` is text that our tool wrote, never text from the model.
+ */
+export function labelToolFailure(type, message) {
+    const span = trace.getActiveSpan();
+    if (span === undefined)
+        return;
+    span.setAttribute("error.type", type);
+    if (message !== undefined)
+        span.setAttribute("inflexa.tool.error", message.slice(0, TOOL_ERROR_MAX_CHARS));
+}
+function errorTypeOf(err) {
+    const code = "code" in err ? err.code : undefined;
+    if ((typeof code === "string" && code !== "") || typeof code === "number")
+        return String(code);
+    return err.name === "" ? "_OTHER" : err.name;
+}
 function withSpan(name, attributes, run) {
     return trace.getTracer("@inflexa-ai/harness").startActiveSpan(name, { attributes }, async (span) => {
         try {

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

@@ -4,6 +4,7 @@ import { createNoopUsageRecorder } from "../billing/noop-usage-recorder.js";
 import { stripNulCharacters } from "../input-sanitization.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { ATTR_INFLEXA_TOOL_USE_ID, stableSpan } from "../lib/otel-spans.js";
+import { ResultError } from "../lib/result.js";
 import { hintForZodIssue, repairToolInput } from "../lib/zod-issues.js";
 import { markInterruptedMessage, syntheticUserMessage } from "../memory/ai-sdk-message-storage.js";
 import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
@@ -13,7 +14,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 { labelToolFailure, recordToolException, 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";
@@ -602,6 +603,7 @@ function readDispatchedStep(settled) {
 async function dispatchTool(tu, toolsById, ctx, isFatalLoopError, encoding) {
     const tool = toolsById.get(tu.toolName);
     if (tool === undefined) {
+        labelToolFailure("unknown_tool");
         return { result: errorResult(tu, `unknown tool: ${tu.toolName}`) };
     }
     const parsed = tool.inputSchema.safeParse(tu.input);
@@ -615,13 +617,17 @@ async function dispatchTool(tu, toolsById, ctx, isFatalLoopError, encoding) {
     const repaired = repairedInput === undefined ? undefined : tool.inputSchema.safeParse(repairedInput);
     if (repaired?.success === true)
         return execute(tu, tool, repaired.data, ctx, isFatalLoopError, encoding);
+    // The Zod text can quote the input, thus the span gets no message.
+    labelToolFailure("validation");
     return { result: errorResult(tu, `input validation failed: ${formatZodIssues(parsed.error, tu.input)}`) };
 }
 async function execute(tu, tool, input, ctx, isFatalLoopError, encoding) {
     try {
         const output = await tool.execute(input, ctx);
-        if (output.isErr())
+        if (output.isErr()) {
+            markToolFailure(tu, tool, output.error, encoding.log);
             return { result: errorResult(tu, toolErrorContent(output.error)) };
+        }
         // The one place a result description runs: the ok value in hand, the
         // input already validated, and the guard inside the compute.
         const detail = computeResultDetail(tool, input, output.value, encoding.log);
@@ -633,9 +639,35 @@ async function execute(tu, tool, input, ctx, isFatalLoopError, encoding) {
             throw err;
         if (isAskRejected(err))
             return { result: deniedResult(tu, err.feedback) };
+        markToolFailure(tu, tool, err, encoding.log);
         return { result: errorResult(tu, toolErrorContent(err)) };
     }
 }
+/**
+ * Label the span of a tool call that our tool code failed. A `ToolError` is a
+ * failure that the tool modeled, thus its own text is the account, with no
+ * exception and no log. Any other `Error` is a fault that the tool did not
+ * model: the span records the exception, and the log gets one warn.
+ */
+function markToolFailure(tu, tool, failure, log) {
+    const toolError = modeledToolError(failure);
+    if (toolError !== undefined) {
+        labelToolFailure("tool_error", toolError.error);
+    }
+    else if (failure instanceof Error) {
+        recordToolException(failure);
+        log.warn("tool call threw", { tool: tool.id, toolCallId: tu.toolCallId, ...log.errorFields(failure) });
+    }
+    else {
+        labelToolFailure("_OTHER");
+    }
+}
+/** The `ToolError` of a failure: the value itself, or the value that `unwrapOrThrow` wrapped in a `ResultError`. */
+function modeledToolError(failure) {
+    if (isToolError(failure))
+        return failure;
+    return failure instanceof ResultError && isToolError(failure.value) ? failure.value : undefined;
+}
 /**
  * Normalize a tool's return value to plain JSON, stripping NUL from every string
  * it holds ({@link stripNulCharacters}). The reviver sees values, not keys — a
@@ -700,8 +732,9 @@ function successResult(toolCall, value, encoding) {
 // is the six-character escape \u0000 — legitimate JSON text, and no longer
 // distinguishable from an error that happens to quote that escape.
 function toolErrorContent(value) {
-    if (isToolError(value)) {
-        return JSON.stringify({ error: stripNulCharacters(value.error), retryable: value.retryable });
+    const toolError = modeledToolError(value);
+    if (toolError !== undefined) {
+        return JSON.stringify({ error: stripNulCharacters(toolError.error), retryable: toolError.retryable });
     }
     const { retryable } = classifyProviderError(value);
     const error = stripNulCharacters(value instanceof Error ? value.message : String(value));

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;