@inflexa-ai/harness 0.17.0 → 0.19.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/agents/report-session-agent.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The Report Builder agent -- the agent that talks to the user on a report thread.
+ *
+ * `createReportSessionAgent` is the composition root of the report path. It gets
+ * the shared deps one time, and it hands each tool exactly what it needs. The
+ * authoring tools and the preview tool bind to the session-state gateway, thus one
+ * assembled definition serves every thread, and the per-session state stays behind
+ * the tool boundary.
+ *
+ * The roster is read-only toward the analysis. It holds the workspace read tools,
+ * the workspace search, the run inspection, and the data-profile inspection. It
+ * holds no planner, no run launcher, no working-memory write, and no sandbox
+ * mutate surface. Thus no tool starts a run, and no tool changes an analysis. The
+ * roster omits those tools, and no runtime guard blocks them.
+ *
+ * The definition carries no per-session value. The system prompt composes through
+ * `composeSystemPrompt` with the identity part and the conversational part, the
+ * same composition as the conversation agent. Thus the prompt prefix stays constant
+ * across threads, and the provider cache reuses it.
+ */
+import type { Pool } from "pg";
+import type { AgentDefinition } from "../loop/types.js";
+import type { EmbeddingProvider } from "../providers/types.js";
+import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
+import type { ResolveWorkspaceRoot } from "../workspace/paths.js";
+import type { Logger } from "../lib/logger.js";
+import type { ReferenceResolver } from "../report-model/reference-resolver.js";
+import type { ReportSessionStateGateway } from "../tools/report-authoring/authoring-tools.js";
+/** Canonical agent id -- distinct from the id of the old templating agent. */
+export declare const REPORT_SESSION_AGENT_ID: "report-session";
+/**
+ * The shared dependencies of the report agent. The gateway binds the per-session
+ * state to the thread, thus every tool that touches the state gets the same
+ * gateway. The resolver is optional, because a resolver realization can be absent,
+ * and the preview tool degrades as data when it is.
+ */
+export interface ReportSessionAgentDeps {
+    /** Model id -- the provenance and metric label. The provider owns the wire model. */
+    readonly model: string;
+    /** Postgres pool -- workspace index, run inspection, and data-profile inspection. */
+    readonly pool: Pool;
+    /** Embedding seam -- workspace semantic search. */
+    readonly embedding: EmbeddingProvider;
+    /** Workspace filesystem read seam -- the four read tools. */
+    readonly workspaceFs: WorkspaceFilesystem;
+    /** Session-state gateway -- the authoring tools and the preview tool bind to it. */
+    readonly gateway: ReportSessionStateGateway;
+    /** Workspace-root resolution seam -- the preview tool resolves the page root per call. */
+    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    /** Reference-resolution seam -- absent until a realization lands; the preview tool degrades as data. */
+    readonly resolver?: ReferenceResolver;
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
+}
+/** Build the report `AgentDefinition` with every tool bound to its deps. */
+export declare function createReportSessionAgent(deps: ReportSessionAgentDeps): AgentDefinition;

package/dist/agents/report-session-agent.js

@@ -0,0 +1,72 @@
+/**
+ * The Report Builder agent -- the agent that talks to the user on a report thread.
+ *
+ * `createReportSessionAgent` is the composition root of the report path. It gets
+ * the shared deps one time, and it hands each tool exactly what it needs. The
+ * authoring tools and the preview tool bind to the session-state gateway, thus one
+ * assembled definition serves every thread, and the per-session state stays behind
+ * the tool boundary.
+ *
+ * The roster is read-only toward the analysis. It holds the workspace read tools,
+ * the workspace search, the run inspection, and the data-profile inspection. It
+ * holds no planner, no run launcher, no working-memory write, and no sandbox
+ * mutate surface. Thus no tool starts a run, and no tool changes an analysis. The
+ * roster omits those tools, and no runtime guard blocks them.
+ *
+ * The definition carries no per-session value. The system prompt composes through
+ * `composeSystemPrompt` with the identity part and the conversational part, the
+ * same composition as the conversation agent. Thus the prompt prefix stays constant
+ * across threads, and the provider cache reuses it.
+ */
+import { createReportAuthoringTools } from "../tools/report-authoring/authoring-tools.js";
+import { createPreviewReportTool } from "../tools/report-session/preview-report.js";
+import { createFileStatTool, createGrepTool, createListFilesTool, createReadFileTool, createWorkspaceSearchTool } from "../tools/workspace/index.js";
+import { createInspectDataProfileTool, createInspectRunTool } from "../tools/research/index.js";
+import { reportSessionPrompt } from "../prompts/report-session.js";
+import { composeSystemPrompt } from "./system-prompt.js";
+/** Canonical agent id -- distinct from the id of the old templating agent. */
+export const REPORT_SESSION_AGENT_ID = "report-session";
+/**
+ * Runaway guard. A report turn drives many small tool calls, thus it needs the
+ * same headroom as the conversation agent.
+ */
+const REPORT_SESSION_MAX_ITERATIONS = 50;
+/** Build the report `AgentDefinition` with every tool bound to its deps. */
+export function createReportSessionAgent(deps) {
+    const { model, pool, embedding, workspaceFs, gateway, resolveWorkspaceRoot, resolver, logger } = deps;
+    const authoring = createReportAuthoringTools(gateway);
+    const tools = [
+        // The read surface toward the analysis. It roams the tree read-only.
+        createReadFileTool(workspaceFs),
+        createListFilesTool(workspaceFs),
+        createFileStatTool(workspaceFs),
+        createGrepTool(workspaceFs),
+        createWorkspaceSearchTool(pool, embedding),
+        createInspectRunTool(pool),
+        createInspectDataProfileTool(pool),
+        // The composition surface. Each authoring tool binds to the gateway, thus
+        // two threads never share one draft.
+        authoring.add_block,
+        authoring.change_block,
+        authoring.remove_block,
+        authoring.move_block,
+        authoring.set_title,
+        authoring.read_outline,
+        authoring.read_block,
+        authoring.finish_draft,
+        // The render-and-preview tool. It resolves the page root per call.
+        createPreviewReportTool({
+            gateway,
+            resolveWorkspaceRoot,
+            ...(resolver ? { resolver } : {}),
+            ...(logger ? { logger } : {}),
+        }),
+    ];
+    return {
+        id: REPORT_SESSION_AGENT_ID,
+        systemPrompt: composeSystemPrompt(reportSessionPrompt, { identity: true, conversational: true }),
+        model,
+        tools,
+        maxIterations: REPORT_SESSION_MAX_ITERATIONS,
+    };
+}

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

@@ -0,0 +1,72 @@
+/**
+ * The report session-state runtime -- the durable realization of the session-state
+ * gateway, and the idempotent operation that anchors one report session.
+ *
+ * The runtime binds three parts: the session-state store, the thread store, and
+ * the pin. The tool layer speaks the gateway, and the gateway speaks a plain
+ * discriminated value. Thus the neverthrow of the store stays inside this module,
+ * and it never crosses the tool boundary.
+ *
+ * `ensureSessionState` makes sure that the row of a thread exists. The first run
+ * resolves the analysis of the thread, pins the snapshot, and writes the row. A
+ * later run reads the row and pins nothing. The store insert-if-absent keeps two
+ * concurrent first runs to one row. A pin failure writes no row and returns as
+ * typed data, thus a later run pins again.
+ *
+ * The gateway `load` runs the same operation, thus a tool call never arrives
+ * before the state exists. A fresh row holds the snapshot and no document yet.
+ * Thus `load` gives the empty draft with the stored snapshot, because the pin
+ * writes the snapshot first and the document lands later.
+ *
+ * A store fault, an absent thread, and a pin failure each ride the failed arm
+ * with a short detail. The diagnostic goes to the injected `Logger`, never to the
+ * detail alone.
+ *
+ * The gateway load separates a permanent condition from a transient one. An absent
+ * thread and a wrong thread type are permanent, and a store or pin fault is
+ * transient. The persist is a compare-and-swap against the prior document that the
+ * load read, thus two concurrent turns cannot both land.
+ */
+import type { Pool } from "pg";
+import type { Logger } from "../lib/logger.js";
+import { type ReportSessionState as StoredSessionState } from "../state/report-session-state.js";
+import type { ReportSessionStateGateway } from "../tools/report-authoring/authoring-tools.js";
+/**
+ * How a failed anchor ends. `absent-thread` and `wrong-thread-type` are permanent
+ * conditions, and `unavailable` is a transient store or pin fault. The gateway load
+ * carries the distinction, thus the tool tells a permanent refusal from a transient one.
+ */
+export type EnsureFailureKind = "absent-thread" | "wrong-thread-type" | "unavailable";
+/**
+ * The outcome of the anchor operation. `ready` carries the durable row, whose
+ * document is `null` until the first document lands. `failed` names the cause as a
+ * short detail and a kind, and the runtime logs the diagnostic beside it.
+ */
+export type EnsureSessionStateResult = {
+    outcome: "ready";
+    state: StoredSessionState;
+} | {
+    outcome: "failed";
+    kind: EnsureFailureKind;
+    detail: string;
+};
+export interface ReportSessionRuntimeDeps {
+    readonly pool: Pool;
+    readonly logger?: Logger;
+}
+/**
+ * The report session-state runtime. The gateway serves the authoring tools, and
+ * `ensureSessionState` anchors the session. The serving path of a report turn runs
+ * `ensureSessionState` at the turn start, and the gateway `load` runs it too, thus
+ * a tool call cannot arrive before the state exists.
+ */
+export interface ReportSessionRuntime {
+    readonly gateway: ReportSessionStateGateway;
+    ensureSessionState(threadId: string): Promise<EnsureSessionStateResult>;
+}
+/**
+ * Build the report session-state runtime bound to a Postgres pool. The factory
+ * closure captures the pool and constructs the session-state store and the thread
+ * store from it, the same way the chat-turn preparation does.
+ */
+export declare function createReportSessionRuntime(deps: ReportSessionRuntimeDeps): ReportSessionRuntime;

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

@@ -0,0 +1,157 @@
+/**
+ * The report session-state runtime -- the durable realization of the session-state
+ * gateway, and the idempotent operation that anchors one report session.
+ *
+ * The runtime binds three parts: the session-state store, the thread store, and
+ * the pin. The tool layer speaks the gateway, and the gateway speaks a plain
+ * discriminated value. Thus the neverthrow of the store stays inside this module,
+ * and it never crosses the tool boundary.
+ *
+ * `ensureSessionState` makes sure that the row of a thread exists. The first run
+ * resolves the analysis of the thread, pins the snapshot, and writes the row. A
+ * later run reads the row and pins nothing. The store insert-if-absent keeps two
+ * concurrent first runs to one row. A pin failure writes no row and returns as
+ * typed data, thus a later run pins again.
+ *
+ * The gateway `load` runs the same operation, thus a tool call never arrives
+ * before the state exists. A fresh row holds the snapshot and no document yet.
+ * Thus `load` gives the empty draft with the stored snapshot, because the pin
+ * writes the snapshot first and the document lands later.
+ *
+ * A store fault, an absent thread, and a pin failure each ride the failed arm
+ * with a short detail. The diagnostic goes to the injected `Logger`, never to the
+ * detail alone.
+ *
+ * The gateway load separates a permanent condition from a transient one. An absent
+ * thread and a wrong thread type are permanent, and a store or pin fault is
+ * transient. The persist is a compare-and-swap against the prior document that the
+ * load read, thus two concurrent turns cannot both land.
+ */
+import { createNoopLogger } from "../lib/console-logger.js";
+import { describeDbError } from "../lib/db-result.js";
+import { createThreadStore } from "../memory/thread-store.js";
+import { pinReportSnapshot } from "../report-model/pin-snapshot.js";
+import { createReportSessionStateStore } from "../state/report-session-state.js";
+/** The empty draft of a fresh session. The pin writes the snapshot first, thus the document is empty here. */
+const EMPTY_DRAFT = { title: "", sections: [] };
+/**
+ * Build the report session-state runtime bound to a Postgres pool. The factory
+ * closure captures the pool and constructs the session-state store and the thread
+ * store from it, the same way the chat-turn preparation does.
+ */
+export function createReportSessionRuntime(deps) {
+    const { pool } = deps;
+    const log = (deps.logger ?? createNoopLogger()).named("report-session-runtime");
+    const store = createReportSessionStateStore({ pool, logger: deps.logger });
+    const threads = createThreadStore(pool);
+    /**
+     * A store read or write fault, as a failed outcome. `corrupt_session_state`
+     * names the part that cannot parse. A `DbError` carries its cause to the log.
+     * The identifiers ride as structured fields, never in the message.
+     */
+    function storeFault(threadId, error) {
+        if (error.type === "corrupt_session_state") {
+            log.error("the stored session state cannot parse", { threadId, part: error.part });
+            return { outcome: "failed", kind: "unavailable", detail: `the stored ${error.part} of the session state cannot parse` };
+        }
+        log.error("the session-state store failed", { threadId, ...log.errorFields(error.cause) });
+        return { outcome: "failed", kind: "unavailable", detail: describeDbError(error) };
+    }
+    /**
+     * Pin the snapshot and write the row. A pin failure writes no row, thus a
+     * later run pins again. The write is insert-if-absent, thus two concurrent
+     * first runs make one row and both read the winner back.
+     */
+    async function pinAndWrite(threadId, analysisId) {
+        const pinned = await pinReportSnapshot(pool, analysisId);
+        if (pinned.isErr()) {
+            log.error("the snapshot pin failed", { threadId, analysisId, ...log.errorFields(pinned.error.cause) });
+            return { outcome: "failed", kind: "unavailable", detail: "the artifact ledger read failed" };
+        }
+        const written = await store.writeSnapshot({ threadId, analysisId, snapshot: pinned.value });
+        return written.match((row) => ({ outcome: "ready", state: row }), (error) => storeFault(threadId, error));
+    }
+    async function ensureSessionState(threadId) {
+        const read = await store.readState(threadId);
+        if (read.isErr()) {
+            return storeFault(threadId, read.error);
+        }
+        if (read.value !== null) {
+            // The row exists, thus the anchor holds and the pin stays single.
+            return { outcome: "ready", state: read.value };
+        }
+        const thread = await threads.getThread(threadId);
+        if (thread.isErr()) {
+            log.error("the thread read failed", { threadId, ...log.errorFields(thread.error.cause) });
+            return { outcome: "failed", kind: "unavailable", detail: describeDbError(thread.error) };
+        }
+        if (thread.value === null) {
+            // The pin needs the analysis of the thread. An absent thread names none, and
+            // the absence is a permanent condition.
+            log.error("the thread resolves to no analysis", { threadId });
+            return { outcome: "failed", kind: "absent-thread", detail: "the thread names no analysis" };
+        }
+        if (thread.value.threadType !== "report") {
+            // The session anchors a report thread only. A conversation thread carries no report session,
+            // thus a wrong type writes no row and the detail names the type. The wrong type is permanent.
+            log.error("the thread is not a report thread", { threadId, threadType: thread.value.threadType });
+            return { outcome: "failed", kind: "wrong-thread-type", detail: `the thread is a ${thread.value.threadType} thread, not a report thread` };
+        }
+        return pinAndWrite(threadId, thread.value.analysisId);
+    }
+    /**
+     * Map the durable row onto the gateway load. A fresh row holds the snapshot and
+     * no document, thus the load gives the empty draft. The found load carries the
+     * stored analysis and the prior document as the concurrency token. A row with no
+     * snapshot cannot serve a tool, because the pin writes the snapshot first.
+     */
+    function toLoad(state) {
+        if (state.snapshot === null) {
+            log.error("the session-state row holds no snapshot", { threadId: state.threadId });
+            return { outcome: "failed", detail: "the session state holds no snapshot" };
+        }
+        return {
+            outcome: "found",
+            state: { document: state.document ?? EMPTY_DRAFT, snapshot: state.snapshot },
+            analysisId: state.analysisId,
+            token: state.document,
+        };
+    }
+    const gateway = {
+        async load(threadId) {
+            const ensured = await ensureSessionState(threadId);
+            if (ensured.outcome === "failed") {
+                switch (ensured.kind) {
+                    case "absent-thread":
+                        return { outcome: "absent" };
+                    case "wrong-thread-type":
+                        return { outcome: "wrong-type", detail: ensured.detail };
+                    case "unavailable":
+                        return { outcome: "failed", detail: ensured.detail };
+                }
+            }
+            return toLoad(ensured.state);
+        },
+        async persist(threadId, document, expected) {
+            const result = await store.persistDocument({ threadId, document, expected });
+            return result.match((outcome) => {
+                switch (outcome) {
+                    case "persisted":
+                        return { outcome: "persisted" };
+                    case "conflict":
+                        // A concurrent turn landed first. The turn refuses and reads the state again.
+                        return { outcome: "conflict" };
+                    case "absent":
+                        // The pin writes the row first. A persist that finds no row means the
+                        // pin-first invariant broke.
+                        log.error("the session-state persist matched no row", { threadId });
+                        return { outcome: "failed", detail: "no report session state row exists to persist the document" };
+                }
+            }, (error) => {
+                log.error("the session-state persist failed", { threadId, ...log.errorFields(error.cause) });
+                return { outcome: "failed", detail: describeDbError(error) };
+            });
+        },
+    };
+    return { gateway, ensureSessionState };
+}

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