@inflexa-ai/harness 0.17.0 → 0.18.0

package/dist/agents/report-builder.d.ts

@@ -19,6 +19,8 @@
 import type { AgentDefinition } from "../loop/types.js";
 import type { Tool } from "../tools/define-tool.js";
 export declare const REPORT_BUILDER_AGENT_ID = "report-builder";
+/** Skill pack the report-builder prompt directs the model to read (design-system reference). */
+export declare const REPORT_BUILDER_SKILLS: readonly ["report-html"];
 export interface CreateReportBuilderAgentDeps {
     /** Model id — provenance / metric label; the provider owns the wire model. */
     readonly model: string;

package/dist/agents/report-builder.js

@@ -19,6 +19,8 @@
 import { reportBuilderPrompt } from "../prompts/report-builder.js";
 import { composeSystemPrompt } from "./system-prompt.js";
 export const REPORT_BUILDER_AGENT_ID = "report-builder";
+/** Skill pack the report-builder prompt directs the model to read (design-system reference). */
+export const REPORT_BUILDER_SKILLS = ["report-html"];
 /** Runaway guard — Jinja recovery may take several build/edit cycles. */
 const REPORT_BUILDER_MAX_ITERATIONS = 75;
 export function createReportBuilderAgent(deps) {

package/dist/app/spawn-report-session.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Report-session spawn — the host-agnostic operation that makes a `report`
+ * child thread from a conversation.
+ *
+ * The operation owns no table. It composes four reads and writes the store and
+ * the thread history already give: `getThread` for the parent, `latestSeq` for
+ * the anchor, `listThreads` for the count of report children, and
+ * `createThread` for the insert. The one storage read this capability adds,
+ * `latestSeq`, lives on the thread history, because that module owns the
+ * `messages` table.
+ *
+ * The reads and the insert take no lock and no transaction. A concurrent turn
+ * can append between the anchor read and the insert, and a retract can cut the
+ * parent's tail. A transaction cannot keep the parent still one turn later, so
+ * a lock buys no real guarantee. The anchor records the spawn point, and skew
+ * past the parent's current end is a normal state a reader expects.
+ *
+ * A conversation thread id comes from the host UI. But the spawn is a harness
+ * operation with no UI in front of it. Thus it mints a `randomUUID` and returns
+ * the full row. A managed deployment gets the same behavior with no host code.
+ */
+import { type ResultAsync } from "neverthrow";
+import type { Pool } from "pg";
+import type { DbError } from "../lib/db-result.js";
+import { type Thread, type ThreadInputError, type ThreadPage, type ThreadType } from "../memory/thread-store.js";
+/**
+ * A spawn the operation refuses before it writes a row. Distinct from
+ * `DbError`: nothing failed at the driver — the parent names a session the
+ * spawn refuses, and each variant carries the identifiers that say which values
+ * disagreed.
+ *
+ * The set is closed. `parent_not_found` covers an absent parent and an archived
+ * one alike, because `getThread` filters the tombstone and a spawn into hidden
+ * state is not permitted. `parent_not_a_conversation` keeps the tree flat: a
+ * report session cannot spawn another. `empty_parent_transcript` refuses a
+ * report on a parent that holds no messages, because such a report reports
+ * nothing.
+ */
+export type SpawnRefusal = {
+    readonly type: "parent_not_found";
+    readonly op: string;
+    readonly parentThreadId: string;
+} | {
+    readonly type: "parent_not_a_conversation";
+    readonly op: string;
+    readonly parentThreadId: string;
+    readonly threadType: ThreadType;
+} | {
+    readonly type: "empty_parent_transcript";
+    readonly op: string;
+    readonly parentThreadId: string;
+};
+/** The paging inputs `listReportSessions` forwards to the thread listing. */
+export interface ReportSessionPaging {
+    readonly page?: number;
+    readonly perPage?: number;
+}
+export interface ReportSessionSpawnDeps {
+    readonly pool: Pool;
+}
+export interface ReportSessionSpawn {
+    /**
+     * Make a `report` child of the parent conversation and return the full row.
+     * The child takes the analysis of the parent, the parent thread id, and the
+     * anchor — the parent's latest `messages.seq` at this moment.
+     *
+     * Refused with a `SpawnRefusal`, no row written: an absent or archived
+     * parent, a parent that is not a conversation, and a parent with no
+     * messages. A store refusal (`DbError`, `ThreadInputError`) passes through
+     * unchanged.
+     */
+    spawnReportSession(parentThreadId: string): ResultAsync<Thread, SpawnRefusal | DbError | ThreadInputError>;
+    /**
+     * The report sessions of one analysis, through the thread listing narrowed
+     * to the type `report`. It adds no predicate of its own, so its answer and
+     * the thread listing cannot disagree.
+     */
+    listReportSessions(analysisId: string, paging?: ReportSessionPaging): ResultAsync<ThreadPage, DbError>;
+}
+/**
+ * Build the report-session operations bound to a Postgres pool. The factory
+ * closure captures `pool` and constructs the store and the thread history from
+ * it, the same way the chat-turn preparation does.
+ */
+export declare function createReportSessionSpawn(deps: ReportSessionSpawnDeps): ReportSessionSpawn;

package/dist/app/spawn-report-session.js

@@ -0,0 +1,83 @@
+/**
+ * Report-session spawn — the host-agnostic operation that makes a `report`
+ * child thread from a conversation.
+ *
+ * The operation owns no table. It composes four reads and writes the store and
+ * the thread history already give: `getThread` for the parent, `latestSeq` for
+ * the anchor, `listThreads` for the count of report children, and
+ * `createThread` for the insert. The one storage read this capability adds,
+ * `latestSeq`, lives on the thread history, because that module owns the
+ * `messages` table.
+ *
+ * The reads and the insert take no lock and no transaction. A concurrent turn
+ * can append between the anchor read and the insert, and a retract can cut the
+ * parent's tail. A transaction cannot keep the parent still one turn later, so
+ * a lock buys no real guarantee. The anchor records the spawn point, and skew
+ * past the parent's current end is a normal state a reader expects.
+ *
+ * A conversation thread id comes from the host UI. But the spawn is a harness
+ * operation with no UI in front of it. Thus it mints a `randomUUID` and returns
+ * the full row. A managed deployment gets the same behavior with no host code.
+ */
+import { randomUUID } from "node:crypto";
+import { errAsync } from "neverthrow";
+import { createThreadHistory } from "../memory/thread-history.js";
+import { createThreadStore } from "../memory/thread-store.js";
+const _assertDomainError = true;
+const OP = "spawn-report-session";
+/**
+ * Compose the child title. N counts the existing report children of the parent
+ * plus one. A parent with no title yields `Report N` alone, because the seed of
+ * the parent title is best-effort and can be absent.
+ */
+function composeTitle(parentTitle, n) {
+    const suffix = `Report ${n}`;
+    return parentTitle && parentTitle.length > 0 ? `${parentTitle} — ${suffix}` : suffix;
+}
+/**
+ * Build the report-session operations bound to a Postgres pool. The factory
+ * closure captures `pool` and constructs the store and the thread history from
+ * it, the same way the chat-turn preparation does.
+ */
+export function createReportSessionSpawn(deps) {
+    const { pool } = deps;
+    const store = createThreadStore(pool);
+    const history = createThreadHistory(pool);
+    function spawnReportSession(parentThreadId) {
+        return store.getThread(parentThreadId).andThen((parent) => {
+            // An absent parent and an archived one arrive the same way — `getThread`
+            // filters the tombstone — and both refuse as `parent_not_found`.
+            if (parent === null) {
+                return errAsync({ type: "parent_not_found", op: OP, parentThreadId });
+            }
+            // The tree stays flat: only a conversation spawns a report.
+            if (parent.threadType !== "conversation") {
+                return errAsync({ type: "parent_not_a_conversation", op: OP, parentThreadId, threadType: parent.threadType });
+            }
+            return history.latestSeq(parentThreadId).andThen((anchor) => {
+                // `null` is a parent with no messages. A report on an empty transcript
+                // reports nothing, so the refusal is the correct answer.
+                if (anchor === null) {
+                    return errAsync({ type: "empty_parent_transcript", op: OP, parentThreadId });
+                }
+                // `total`, not the page length: N counts every existing report child,
+                // not the count on one page. Two concurrent spawns can compose one N.
+                // The result is two titles a user renames, and no identifier collides.
+                return store
+                    .listThreads({ analysisId: parent.analysisId, type: "report", parentThreadId })
+                    .andThen((children) => store.createThread({
+                    threadId: randomUUID(),
+                    analysisId: parent.analysisId,
+                    title: composeTitle(parent.title, children.total + 1),
+                    type: "report",
+                    parentThreadId,
+                    parentSeq: anchor,
+                }));
+            });
+        });
+    }
+    function listReportSessions(analysisId, paging = {}) {
+        return store.listThreads({ analysisId, type: "report", ...paging });
+    }
+    return { spawnReportSession, listReportSessions };
+}

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

@@ -84,6 +84,15 @@ export interface ToolFinishedEvent {
     outcome: ToolOutcome;
     /** The same detail the matching `tool-started` carried. */
     detail?: ToolCallDetail;
+    /**
+     * The time in milliseconds around this call's own dispatch. Absent — never
+     * zero — when the harness took no measurement.
+     *
+     * A host must read it as `event.durationMs ?? (its own bracket)`. The bracket
+     * of a host spans the whole round, because the loop emits every start before
+     * it dispatches anything. Thus the fallback is correct only for one call.
+     */
+    durationMs?: number;
     source: EventSource;
 }
 /**

package/dist/contracts/index.d.ts

@@ -1,3 +1,7 @@
+export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel } from "./organ-system.js";
+export type { OrganSystem } from "./organ-system.js";
+export { SEVERITIES, SeveritySchema } from "./severity.js";
+export type { Severity } from "./severity.js";
 export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, DagStatePart, StepPhase, StepActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, PreviewPart, DataPreviewFailedPart, CortexChatPart, } from "./chat-parts.js";
 export type { EventSource, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, CortexChatEvent } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
@@ -7,8 +11,8 @@ 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, EntitySchema, SummarySchema, LiabilitySummarySchema, TractabilitySchema, IndicationsSchema, DrugInteractionsSchema, ClinicalDevelopmentSchema, SafetyProfileSchema, OffTissueRiskSchema, EvidenceConflictsSchema, EvidenceTimelineSchema, TranslationalChainSchema, AdditionalEvidenceSchema, DiscoveryTrialsSchema, DossierSchema, DossierSchemaV3Legacy, DossierV4Schema, DossierV5Schema, DossierV5BodySchema, ClinicalTrialAttributionV5Schema, ClinicalDevelopmentV5Schema, RegulatoryActionRowV5Schema, QualityGateStatusSchema, QualityGatesSchema, LiabilitySummaryV4Schema, ClinicalDevelopmentV4Schema, SafetyProfileV4Schema, OrganRiskRowV4Schema, ReferenceBiologyV4Shape, isDossier, dossierJsonSchema, SECTION_BLURBS, TargetAssessmentPhaseSchema, TargetAssessmentProgressEventSchema, } from "./target-dossier.js";
-export type { Coverage, Entity, Summary, LiabilitySummary, TractabilitySection, EvidenceItem, Dossier, DossierV4, DossierV5, DossierV5Body, ClinicalTrialAttributionV5, ClinicalTrialRowV5, FailedTrialRowV5, TrialOutcomeRowV5, RegulatoryActionRowV5, QualityGateStatus, QualityGates, SectionBlurbKey, TargetAssessmentPhase, TargetAssessmentProgressEvent, } from "./target-dossier.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 { buildPreviewUrl, previewResourceId } from "./content-url.js";

package/dist/contracts/index.js

@@ -1,6 +1,8 @@
+export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel } from "./organ-system.js";
+export { SEVERITIES, SeveritySchema } from "./severity.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";
-export { CoverageSchema, EntitySchema, SummarySchema, LiabilitySummarySchema, TractabilitySchema, IndicationsSchema, DrugInteractionsSchema, ClinicalDevelopmentSchema, SafetyProfileSchema, OffTissueRiskSchema, EvidenceConflictsSchema, EvidenceTimelineSchema, TranslationalChainSchema, AdditionalEvidenceSchema, DiscoveryTrialsSchema, DossierSchema, DossierSchemaV3Legacy, DossierV4Schema, DossierV5Schema, DossierV5BodySchema, ClinicalTrialAttributionV5Schema, ClinicalDevelopmentV5Schema, RegulatoryActionRowV5Schema, QualityGateStatusSchema, QualityGatesSchema, LiabilitySummaryV4Schema, ClinicalDevelopmentV4Schema, SafetyProfileV4Schema, OrganRiskRowV4Schema, ReferenceBiologyV4Shape, isDossier, dossierJsonSchema, SECTION_BLURBS, TargetAssessmentPhaseSchema, TargetAssessmentProgressEventSchema, } from "./target-dossier.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 { buildPreviewUrl, previewResourceId } from "./content-url.js";

package/dist/contracts/organ-system.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The canonical organ-system vocabulary.
+ *
+ * This is the ONLY organ vocabulary in the package. Per-organ evidence is
+ * joined by equality on these tokens, so a second enumeration — even a
+ * "temporary" or deprecated one — reintroduces the string matching this
+ * exists to remove. Producers resolve external and model-supplied organ
+ * names onto these tokens at their own boundary.
+ *
+ * Membership is anatomical, with one deliberate exception: `oncology` is a
+ * therapeutic area rather than an organ system, so grouping by it does not
+ * denote a site. It is retained because malignancy signals — MedDRA neoplasm
+ * SOC terms, and regulatory findings matched on malignancy keywords — have
+ * no other channel to arrive on, and dropping the member would discard them.
+ * Known debt: the honest fix is a separate non-organ signal channel.
+ */
+import { z } from "zod";
+export declare const ORGAN_SYSTEMS: readonly ["cardiac", "vascular", "hepatic", "renal", "cns", "pns", "gi", "pancreas", "endocrine_thyroid", "metabolic", "hematologic", "immune", "respiratory", "reproductive", "musculoskeletal", "dermatologic", "ocular", "oncology"];
+export declare const OrganSystemSchema: z.ZodEnum<{
+    hematologic: "hematologic";
+    metabolic: "metabolic";
+    immune: "immune";
+    hepatic: "hepatic";
+    musculoskeletal: "musculoskeletal";
+    cns: "cns";
+    renal: "renal";
+    reproductive: "reproductive";
+    respiratory: "respiratory";
+    cardiac: "cardiac";
+    vascular: "vascular";
+    pns: "pns";
+    gi: "gi";
+    pancreas: "pancreas";
+    endocrine_thyroid: "endocrine_thyroid";
+    dermatologic: "dermatologic";
+    ocular: "ocular";
+    oncology: "oncology";
+}>;
+export type OrganSystem = (typeof ORGAN_SYSTEMS)[number];
+/**
+ * Reader-facing prose for each canonical token.
+ *
+ * Narrative surfaces (agent voice, rendered dossiers) read these; structured
+ * fields always carry the token. Keeping the prose a projection of the token
+ * — rather than its own list — is what stops the two drifting into the
+ * separate vocabularies this module replaces.
+ */
+export declare const ORGAN_SYSTEM_LABELS: Record<OrganSystem, string>;
+export declare const organSystemLabel: (organ: OrganSystem) => string;

package/dist/contracts/organ-system.js

@@ -0,0 +1,67 @@
+/**
+ * The canonical organ-system vocabulary.
+ *
+ * This is the ONLY organ vocabulary in the package. Per-organ evidence is
+ * joined by equality on these tokens, so a second enumeration — even a
+ * "temporary" or deprecated one — reintroduces the string matching this
+ * exists to remove. Producers resolve external and model-supplied organ
+ * names onto these tokens at their own boundary.
+ *
+ * Membership is anatomical, with one deliberate exception: `oncology` is a
+ * therapeutic area rather than an organ system, so grouping by it does not
+ * denote a site. It is retained because malignancy signals — MedDRA neoplasm
+ * SOC terms, and regulatory findings matched on malignancy keywords — have
+ * no other channel to arrive on, and dropping the member would discard them.
+ * Known debt: the honest fix is a separate non-organ signal channel.
+ */
+import { z } from "zod";
+export const ORGAN_SYSTEMS = [
+    "cardiac",
+    "vascular",
+    "hepatic",
+    "renal",
+    "cns",
+    "pns",
+    "gi",
+    "pancreas",
+    "endocrine_thyroid",
+    "metabolic",
+    "hematologic",
+    "immune",
+    "respiratory",
+    "reproductive",
+    "musculoskeletal",
+    "dermatologic",
+    "ocular",
+    "oncology",
+];
+export const OrganSystemSchema = z.enum(ORGAN_SYSTEMS);
+/**
+ * Reader-facing prose for each canonical token.
+ *
+ * Narrative surfaces (agent voice, rendered dossiers) read these; structured
+ * fields always carry the token. Keeping the prose a projection of the token
+ * — rather than its own list — is what stops the two drifting into the
+ * separate vocabularies this module replaces.
+ */
+export const ORGAN_SYSTEM_LABELS = {
+    cardiac: "cardiac",
+    vascular: "vascular",
+    hepatic: "hepatobiliary",
+    renal: "renal",
+    cns: "central nervous system",
+    pns: "peripheral nervous system",
+    gi: "gastrointestinal",
+    pancreas: "pancreatic",
+    endocrine_thyroid: "endocrine (thyroid)",
+    metabolic: "metabolic",
+    hematologic: "haematologic",
+    immune: "immunologic",
+    respiratory: "respiratory",
+    reproductive: "reproductive",
+    musculoskeletal: "musculoskeletal",
+    dermatologic: "dermatologic",
+    ocular: "ocular",
+    oncology: "oncology",
+};
+export const organSystemLabel = (organ) => ORGAN_SYSTEM_LABELS[organ];