@inflexa-ai/harness 0.48.2 → 0.48.4

package/dist/agents/sandbox/index.js

@@ -20,6 +20,7 @@ import { createDrugRepurposingAgent, meta as drugRepurposingMeta } from "./drug-
 import { createEnrichmentAgent, meta as enrichmentMeta } from "./enrichment-agent.js";
 import { createGenomicVariantAgent, meta as genomicVariantMeta } from "./genomic-variant-agent.js";
 import { createImmuneProfilingAgent, meta as immuneProfilingMeta } from "./immune-profiling-agent.js";
+import { createMdvPreparationAgent, meta as mdvPreparationMeta } from "./mdv-preparation-agent.js";
 import { createMetabolomicsAgent, meta as metabolomicsMeta } from "./metabolomics-agent.js";
 import { createMicrobiomeAgent, meta as microbiomeMeta } from "./microbiome-agent.js";
 import { createMultiOmicsIntegrationAgent, meta as multiOmicsIntegrationMeta } from "./multi-omics-integration-agent.js";
@@ -60,6 +61,7 @@ export const SANDBOX_AGENT_META = {
     [pkpdClinicalResponseMeta.id]: pkpdClinicalResponseMeta,
     [immuneProfilingMeta.id]: immuneProfilingMeta,
     [drugRepurposingMeta.id]: drugRepurposingMeta,
+    [mdvPreparationMeta.id]: mdvPreparationMeta,
     [scientificExecutorMeta.id]: scientificExecutorMeta,
 };
 /**
@@ -88,6 +90,7 @@ export function createSandboxAgents(deps) {
         [pkpdClinicalResponseMeta.id]: createPkpdClinicalResponseAgent(deps),
         [immuneProfilingMeta.id]: createImmuneProfilingAgent(deps),
         [drugRepurposingMeta.id]: createDrugRepurposingAgent(deps),
+        [mdvPreparationMeta.id]: createMdvPreparationAgent(deps),
         [scientificExecutorMeta.id]: createScientificExecutorAgent(deps),
     };
 }

package/dist/agents/sandbox/mdv-preparation-agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MDV Preparation Agent — turns single-cell, scATAC-seq, spatial transcriptomics, and spatial
+ * proteomics data into curated, validated assets that MDV (Multi-Dimensional Viewer) loads.
+ */
+import type { AgentDefinition } from "../../loop/types.js";
+import { type SandboxAgentDeps } from "./shared.js";
+import type { AgentMeta } from "./types.js";
+export declare const meta: AgentMeta;
+export declare function createMdvPreparationAgent(deps: SandboxAgentDeps): AgentDefinition;

package/dist/agents/sandbox/mdv-preparation-agent.js

@@ -0,0 +1,37 @@
+/**
+ * MDV Preparation Agent — turns single-cell, scATAC-seq, spatial transcriptomics, and spatial
+ * proteomics data into curated, validated assets that MDV (Multi-Dimensional Viewer) loads.
+ */
+import { mdvPreparationAgentPrompt } from "../../prompts/sandbox/mdv-preparation-agent.js";
+import { BASE_SANDBOX_TOOLS, createSandboxAgent } from "./shared.js";
+export const meta = {
+    id: "mdv-preparation-agent",
+    capabilities: [
+        "MDV asset preparation",
+        "single-cell data preparation for MDV",
+        "spatial data preparation for MDV",
+        "metadata curation for visualization",
+        "MDV asset validation",
+    ],
+    suitableFor: [
+        "scrna-seq",
+        "snrna-seq",
+        "scatac-seq",
+        "multiome",
+        "cosmx",
+        "xenium",
+        "visium",
+        "merfish",
+        "codex",
+        "imc",
+        "mibi",
+        "anndata",
+        "mudata",
+        "spatialdata",
+    ],
+    skills: ["mdv-preparation", "single-cell", "spatial-omics", "chromatin-regulation", "shared/omics-general"],
+    tools: [...BASE_SANDBOX_TOOLS],
+};
+export function createMdvPreparationAgent(deps) {
+    return createSandboxAgent(deps, meta, mdvPreparationAgentPrompt);
+}

package/dist/app/chat-turn-workflow.d.ts

@@ -15,7 +15,7 @@
  */
 import type { AuthContext } from "../auth/types.js";
 import type { TokenUsageRollup } from "../contracts/usage.js";
-import type { ChatFrame } from "../contracts/chat-events.js";
+import type { ChatErrorEvent, ChatFrame, EventSource, FinishEvent } from "../contracts/chat-events.js";
 import type { AgentDefinition } from "../loop/types.js";
 import type { ThreadType } from "../memory/thread-store.js";
 import type { PromptCachePolicy } from "../providers/types.js";
@@ -110,5 +110,7 @@ export declare const DEFAULT_ASK_WAIT_SECONDS: number;
  * finds the workflow of a recovery by its registered name.
  */
 export declare function registerChatTurns(deps: ChatTurnWorkflowDeps): ChatTurns;
+/** The last frame of a turn that ran: `error` for a failed turn, else `finish` with the stop reason of the turn. */
+export declare function endFrameOf(ran: ChatTurnRan, rootSource: EventSource): ChatErrorEvent | FinishEvent;
 /** How a turn that ran ended, as a host reads it. */
 export declare function chatTurnEndOf(ran: ChatTurnRan): ChatTurnEnd;

package/dist/app/chat-turn-workflow.js

@@ -258,6 +258,7 @@ async function runTurnWorkflow(deps, input, signal) {
             pool: deps.pool,
             workId: input.turnId,
             workKind: "turn",
+            waiter: { kind: "turn" },
             analysisId: input.analysisId,
             threadId: input.threadId,
             emit: async (part) => {
@@ -277,9 +278,7 @@ async function runTurnWorkflow(deps, input, signal) {
     };
     const ran = await runOpenTurn(deps, { analysisId: input.analysisId, threadId: input.threadId, userInput: input.userText }, { kind: "ok", threadType: input.threadType, history: view, userMessage: opening.userMessage, contextRecords: opening.contextRecords }, agent.value, { session, author: input.author, startedAtMs: input.startedAtMs, promptCache: input.promptCache }, transport);
     const { outcome } = ran;
-    await writer.write(outcome.status === "failed"
-        ? { type: "error", message: outcome.reason, reason: outcome.code, source: rootSource }
-        : { type: "finish", source: rootSource, turnUsage: ran.turnUsage });
+    await writer.write(endFrameOf(ran, rootSource));
     await writer.settle();
     await closeDurableStream(CHAT_STREAM_KEY, outcome.status === "done" ? "stop" : outcome.status === "aborted" ? "aborted" : "error");
     // A sub-agent that a stop canceled in its pause leaves its row, thus the end of the turn clears each row of the turn.
@@ -287,6 +286,23 @@ async function runTurnWorkflow(deps, input, signal) {
     await DBOS.runStep(async () => unwrapOrThrow(await releaseThreadOfTurn(deps.pool, input.threadId, input.turnId)), { name: "chat-turn.release" });
     return chatTurnEndOf(ran);
 }
+/** The last frame of a turn that ran: `error` for a failed turn, else `finish` with the stop reason of the turn. */
+export function endFrameOf(ran, rootSource) {
+    const { outcome } = ran;
+    switch (outcome.status) {
+        case "failed":
+            return { type: "error", message: outcome.reason, reason: outcome.code, source: rootSource };
+        case "done":
+            return { type: "finish", source: rootSource, finishReason: outcome.finish.reason, turnUsage: ran.turnUsage };
+        // An abort that cut the run before its end leaves no finish of the loop.
+        case "aborted":
+            return { type: "finish", source: rootSource, finishReason: "aborted", turnUsage: ran.turnUsage };
+        default: {
+            const exhaustive = outcome;
+            throw new Error(`unhandled turn outcome: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
 /** How a turn that ran ended, as a host reads it. */
 export function chatTurnEndOf(ran) {
     const { outcome } = ran;

package/dist/app/chat-turn.d.ts

@@ -56,8 +56,10 @@ export type PreparedChatTurn = Extract<PrepareChatTurnResult, {
  */
 export declare function prepareChatTurn(deps: PrepareChatTurnDeps, params: PrepareChatTurnParams): Promise<PrepareChatTurnResult>;
 /**
- * Open the thread of a turn: check that the analysis owns it, make it when it is absent, and seed its title. A
- * thread that a different analysis owns is `not_found`.
+ * Open the thread of a turn: make it when it is absent, and seed its title. A thread that a different analysis
+ * owns is `not_found`, and so is an archived thread: a turn never writes into hidden state and never restores it.
+ * A failed make of the thread throws, because without its row the open cannot tell an absent thread from one that
+ * it must refuse.
  */
 export declare function openThread(deps: PrepareChatTurnDeps, params: PrepareChatTurnParams): Promise<{
     readonly kind: "ok";

package/dist/app/chat-turn.js

@@ -48,8 +48,10 @@ export async function prepareChatTurn(deps, params) {
     return { kind: "ok", threadType: opened.threadType, ...assembled };
 }
 /**
- * Open the thread of a turn: check that the analysis owns it, make it when it is absent, and seed its title. A
- * thread that a different analysis owns is `not_found`.
+ * Open the thread of a turn: make it when it is absent, and seed its title. A thread that a different analysis
+ * owns is `not_found`, and so is an archived thread: a turn never writes into hidden state and never restores it.
+ * A failed make of the thread throws, because without its row the open cannot tell an absent thread from one that
+ * it must refuse.
  */
 export async function openThread(deps, params) {
     const { pool } = deps;
@@ -58,52 +60,48 @@ export async function openThread(deps, params) {
     // An unbound member gives a call that does nothing, thus the emit below needs
     // no test of its own.
     const observe = bindSessionEmit(deps.provenance, logger);
-    // Ownership check before any read/write of the thread — a `threadId`
-    // owned by a different analysis is indistinguishable from a missing one.
+    // `getThread` hides an archived row, thus a live row is the only one that this
+    // read can prove owned. An absent result covers a missing thread and an
+    // archived one, and the idempotent create below tells them apart.
     const store = createThreadStore(pool);
     const existing = unwrapOrThrow(await store.getThread(threadId));
     if (existing && existing.analysisId !== analysisId) {
         return { kind: "not_found" };
     }
-    // The type a caller resolves the turn's agent from, and the type that the
-    // message assembly reads for its context records. An existing row carries
-    // its own. An absent one defaults to `conversation` — the store's own
-    // default — so a best-effort create that fails non-fatally still leaves a
-    // usable type; a successful create overrides it from the returned row.
-    let threadType = existing ? existing.threadType : "conversation";
-    // Seed the thread title from the first user message. Best-effort.
-    try {
-        if (!existing) {
-            // `createThread` is idempotent (ON CONFLICT reads the row back), so
-            // the returned row is authoritative for the type: a create that
-            // races another writer reflects the stored type, not an assumed one.
-            const created = unwrapOrThrow(await store.createThread({
-                threadId,
-                analysisId,
-                title: deriveThreadTitle(userInput),
-            }));
-            threadType = created.threadType;
-            // The row that comes back is not proof that this call wrote it. The read
-            // above hides an archived thread, and the idempotent insert then reads
-            // that same row back. Thus a turn on an archived thread reaches here with
-            // a row that a different site created, and an emit would record a start
-            // that never happened.
-            //
-            // This site writes a live conversation thread and nothing else. An
-            // archived row, or a row of another kind, is therefore one that already
-            // existed. A root session has no parent, thus the event carries none.
-            if (created.deletedAt === null && created.threadType === "conversation") {
-                observe({ type: "create-session", analysisId, threadId, sessionKind: created.threadType });
-            }
+    if (!existing) {
+        // `createThread` is idempotent (ON CONFLICT reads the row back with no
+        // filter), so the returned row is authoritative: the inserted row, or the
+        // row that already existed, archived or owned by a different analysis. A
+        // conflict writes nothing, thus the refusal comes before each write of the
+        // turn.
+        const created = unwrapOrThrow(await store.createThread({
+            threadId,
+            analysisId,
+            title: deriveThreadTitle(userInput),
+        }));
+        if (created.analysisId !== analysisId || created.deletedAt !== null) {
+            return { kind: "not_found" };
         }
-        else if (!existing.title || existing.title.length === 0) {
-            unwrapOrThrow(await store.setAutoTitle(threadId, deriveThreadTitle(userInput)));
+        // The row that comes back is not proof that this call wrote it: a create
+        // that races another writer reads that writer's row back. This site writes
+        // a live conversation thread and nothing else, thus a row of another kind
+        // is one that already existed. A root session has no parent, thus the event
+        // carries none.
+        if (created.threadType === "conversation") {
+            observe({ type: "create-session", analysisId, threadId, sessionKind: created.threadType });
         }
+        return { kind: "ok", threadType: created.threadType };
     }
-    catch (err) {
-        logger.warn("title-seed failed (non-fatal)", logger.errorFields(err));
+    // Seed the thread title from the first user message. Best-effort.
+    if (!existing.title || existing.title.length === 0) {
+        try {
+            unwrapOrThrow(await store.setAutoTitle(threadId, deriveThreadTitle(userInput)));
+        }
+        catch (err) {
+            logger.warn("title-seed failed (non-fatal)", logger.errorFields(err));
+        }
     }
-    return { kind: "ok", threadType };
+    return { kind: "ok", threadType: existing.threadType };
 }
 /** The analysis context and the run activity of a turn. A failed read gives the fallback of its kind. */
 export async function readTurnContext(pool, analysisId) {
@@ -218,7 +216,7 @@ export async function runOpenTurn(deps, turn, prepared, agent, params, transport
     await flush({
         status: outcome.status,
         reason: outcome.status === "failed" ? outcome.reason : undefined,
-        note: outcome.status === "failed" ? conversationRecordTurn(failureNote(outcome.reason)) : outcome.status === "aborted" ? interruptionNote() : undefined,
+        note: closingNoteOf(outcome, recorder),
         turnUsage,
         turnDurationMs: durationMs,
     });
@@ -292,15 +290,43 @@ function failureReasonOf(err) {
             return findProviderError(err) === undefined ? "The turn stopped on an internal error." : "The model request failed.";
     }
 }
+/** The note that closes a turn: a failed, an aborted, or a declined turn has one, and a turn that the model answered has none. */
+function closingNoteOf(outcome, recorder) {
+    switch (outcome.status) {
+        case "failed": {
+            const note = conversationRecordTurn(failureNote(outcome.reason));
+            return { ...note, displayMessages: [...recorder.openRoundPauses(), ...note.displayMessages] };
+        }
+        case "aborted":
+            return interruptionNote(recorder);
+        case "done":
+            return outcome.finish.reason === "content-filter" ? declineNote(recorder) : undefined;
+        default: {
+            const exhaustive = outcome;
+            throw new Error(`unhandled turn outcome: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+/**
+ * The note of a turn that the content filter stopped. A declined request often gives no message, and a round
+ * with no message gives no row. The note is the row that holds the display of such a round, thus a reload
+ * shows the refusal. It also tells the next turn that this request has no reply.
+ */
+function declineNote(recorder) {
+    return {
+        modelMessages: [syntheticUserMessage("[The model provider declined the request above, thus it has no reply.]")],
+        displayMessages: recorder.takeRound([]),
+    };
+}
 /**
  * The note of an aborted turn. Without it, the next turn reads the request of the aborted turn as open, and
- * its reply also answers that request. The transcript shows the interruption from the turn record, thus the
- * note has no display.
+ * its reply also answers that request. The transcript shows the interruption from the turn record. The display
+ * of the note holds only the pause parts of the open round, thus a reload shows how the wait ended.
  */
-function interruptionNote() {
+function interruptionNote(recorder) {
     return {
         modelMessages: [syntheticUserMessage("[The user interrupted the request above. Do not continue it unless the user asks you to.]")],
-        displayMessages: [],
+        displayMessages: recorder.openRoundPauses(),
     };
 }
 function failureNote(reason) {

package/dist/app/in-process-turn.js

@@ -6,7 +6,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { toChatFrame } from "../contracts/chat-frame.js";
-import { chatTurnEndOf } from "./chat-turn-workflow.js";
+import { chatTurnEndOf, endFrameOf } from "./chat-turn-workflow.js";
 import { createConversationDisplayRecorder } from "../memory/conversation-display-recorder.js";
 import { prepareChatTurn, runOpenTurn, userTextOf, } from "./chat-turn.js";
 /** Prepare a turn and resolve its agent. A refusal comes back before any row of the turn exists. */
@@ -112,11 +112,8 @@ export function inProcessChatTurns(deps) {
                 promptCache: request.promptCache,
             })
                 .then((ran) => {
-                const turnEnd = chatTurnEndOf(ran);
-                log.push(turnEnd.status === "failed"
-                    ? { type: "error", message: turnEnd.reason ?? "The turn failed.", reason: turnEnd.code, source: rootSource }
-                    : { type: "finish", source: rootSource, turnUsage: turnEnd.turnUsage });
-                return turnEnd;
+                log.push(endFrameOf(ran, rootSource));
+                return chatTurnEndOf(ran);
             })
                 .catch(() => null)
                 .finally(() => log.close());

package/dist/app/work.d.ts

@@ -6,7 +6,7 @@
  * of a turn and each step of a run wait in their own workflows. A stop ends a work in each state. A resume and a
  * hold reach only a work that waits. Only a client resumes paused work.
  */
-import type { PauseCause, WorkKind } from "../contracts/chat-parts.js";
+import type { PauseCause, PauseWaiter, WorkKind } from "../contracts/chat-parts.js";
 import type { RunAuthorizer } from "../execution/run-authorizer.js";
 import type { RunCanceler } from "../execution/run-canceler.js";
 import type { Logger } from "../lib/logger.js";
@@ -15,6 +15,8 @@ import type { ChatTurnSession } from "./chat-turn.js";
 /** One waiting workflow of a paused work. */
 export type PausedWorkflow = {
     readonly workflowId: string;
+    /** What waits. Absent for a wait that started before the harness recorded the waiter. */
+    readonly waiter?: PauseWaiter;
     readonly state: "retrying" | "paused";
     readonly cause: PauseCause;
     /** The count of timer retries before this wait. */
@@ -29,6 +31,7 @@ export type Work = {
     /** The turn id, the run id, or the id of the profile workflow. */
     readonly workId: string;
     readonly kind: WorkKind;
+    /** The analysis of the work, as its own row names it. */
     readonly analysisId: string;
     readonly threadId?: string;
     /** Each waiting workflow of the work. Empty for a work that runs. */
@@ -61,10 +64,11 @@ export type WorkHold = {
 /** The durable work of a runtime, as a host uses it. */
 export type WorkSurface = {
     /**
-     * The active work of an analysis: each turn that holds a thread, each `running` run, and the profile that runs.
+     * The active work of an analysis, or of each analysis when `analysisId` is absent: each turn that holds a thread,
+     * each `running` run, and each profile that runs. The count of reads does not depend on the count of analyses.
      * A pause row whose workflow ended is not in it, and the list deletes that row.
      */
-    list(analysisId: string): Promise<Work[]>;
+    list(analysisId?: string): Promise<Work[]>;
     /**
      * Stop the work, in each state: a turn stops, a run cancels with its children, and a profile fails. Work of a
      * different analysis than the session gives `not_found`.

package/dist/app/work.js

@@ -11,9 +11,9 @@ import { createNoopLogger } from "../lib/console-logger.js";
 import { passGate } from "../lib/hooks.js";
 import { unwrapOrThrow } from "../lib/result.js";
 import { turnCredentials } from "../loop/turn-credentials.js";
-import { queryTurnsOfAnalysis } from "../state/active-turns.js";
-import { loadDataProfileStatus } from "../state/data-profile.js";
-import { clearPauses, queryPausesOfAnalysis, queryPausesOfWork } from "../state/paused-work.js";
+import { queryTurns } from "../state/active-turns.js";
+import { queryRunningProfiles } from "../state/data-profile.js";
+import { clearPauses, queryPauses, queryPausesOfWork } from "../state/paused-work.js";
 import { queryActiveRunsByAnalysis } from "../state/runs.js";
 import { HOLD_MESSAGE, RESUME_MESSAGE } from "../workflows/pause.js";
 /** The workflow statuses that can still wait. */
@@ -23,6 +23,7 @@ const WORK_STOP_PROVENANCE = { agentId: "work-stop", callPath: ["work-stop"] };
 function workflowOf(record) {
     return {
         workflowId: record.workflowId,
+        waiter: record.waiter,
         state: record.state,
         cause: record.cause,
         attempt: record.attempt,
@@ -39,17 +40,16 @@ async function activeWorkflows(workflowIds) {
 export function createWork(deps) {
     const logger = (deps.logger ?? createNoopLogger()).named("harness.work");
     async function list(analysisId) {
-        const [records, turns, runs, profile] = await Promise.all([
-            (async () => unwrapOrThrow(await queryPausesOfAnalysis(deps.pool, analysisId)))(),
-            (async () => unwrapOrThrow(await queryTurnsOfAnalysis(deps.pool, analysisId)))(),
+        const [records, turns, runs, profiles] = await Promise.all([
+            (async () => unwrapOrThrow(await queryPauses(deps.pool, analysisId)))(),
+            (async () => unwrapOrThrow(await queryTurns(deps.pool, analysisId)))(),
             (async () => unwrapOrThrow(await queryActiveRunsByAnalysis(deps.pool, analysisId)))(),
-            (async () => unwrapOrThrow(await loadDataProfileStatus(deps.pool, analysisId)))(),
+            (async () => unwrapOrThrow(await queryRunningProfiles(deps.pool, analysisId)))(),
         ]);
-        const profileWorkflowId = profile?.status === "running" ? (profile.workflowId ?? undefined) : undefined;
         const active = await activeWorkflows([
             ...records.map((record) => record.workflowId),
             ...turns.map((turn) => turn.turnId),
-            ...(profileWorkflowId === undefined ? [] : [profileWorkflowId]),
+            ...profiles.map((profile) => profile.workflowId),
         ]);
         const ended = records.filter((record) => !active.has(record.workflowId)).map((record) => record.workflowId);
         if (ended.length > 0) {
@@ -64,23 +64,24 @@ export function createWork(deps) {
             waitingOf.set(record.workId, [...(waitingOf.get(record.workId) ?? []), workflowOf(record)]);
         }
         const work = new Map();
-        const add = (workId, kind, threadId) => {
+        const add = (workId, kind, itemAnalysisId, threadId) => {
             if (work.has(workId))
                 return;
-            work.set(workId, { workId, kind, analysisId, threadId, waiting: waitingOf.get(workId) ?? [] });
+            work.set(workId, { workId, kind, analysisId: itemAnalysisId, threadId, waiting: waitingOf.get(workId) ?? [] });
         };
         // A claim can outlive its turn, thus a turn is active while its workflow is. A `running` run is active while
         // its row is, because the run canceler also converges a row whose workflow ended.
         for (const turn of turns)
             if (active.has(turn.turnId))
-                add(turn.turnId, "turn", turn.threadId);
+                add(turn.turnId, "turn", turn.analysisId, turn.threadId);
         for (const run of runs)
-            add(run.runId, "run", run.threadId ?? undefined);
-        if (profileWorkflowId !== undefined && active.has(profileWorkflowId))
-            add(profileWorkflowId, "profile", undefined);
+            add(run.runId, "run", run.analysisId, run.threadId ?? undefined);
+        for (const profile of profiles)
+            if (active.has(profile.workflowId))
+                add(profile.workflowId, "profile", profile.analysisId, undefined);
         for (const record of records)
             if (active.has(record.workflowId))
-                add(record.workId, record.workKind, record.threadId);
+                add(record.workId, record.workKind, record.analysisId, record.threadId);
         return [...work.values()];
     }
     return {

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

@@ -162,6 +162,11 @@ export type ToolFinishedEvent = {
 export type FinishEvent = {
     type: "finish";
     source: EventSource;
+    /**
+     * Why the turn stopped: the finish reason of the last reply, for example `stop` or `content-filter`, or `aborted`,
+     * `max_iterations`, or `denied`. A word outside these stays as the provider sent it.
+     */
+    finishReason: string;
     /** What this loop's own LLM calls used. */
     usage?: TokenUsageRollup;
     /**

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

@@ -4,17 +4,20 @@
  *
  * Categories:
  *   Presentation:    data-presentation (agent-synthesized content),
- *                    data-plan (plan by id), data-file-reference (files by path)
+ *                    data-plan (plan by id), data-file-reference (files by path),
+ *                    data-analogy-report (the result of generate_analogy_report)
  *   Approval:        data-ask (a tool's pending user-approval prompt),
  *                    data-plan-approval (the record of an approved plan)
  *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Model retry:     data-model-retry (a retry of a model request inside the retry envelope of the provider)
+ *   Model refusal:   data-model-refusal (a model request that the provider declined)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree
  *   Activity history: activity-entry (run stream), subagent-activity (conversation)
  *   Per-step final:  step-output, step-summary, step-usage
  */
+import type { AnalogicalReasonerOutput } from "./analogy-report.js";
 import type { ToolCallOutcome } from "./chat-events.js";
 import type { TokenUsageRollup } from "./usage.js";
 export type PlanStep = {
@@ -71,6 +74,13 @@ export type PresentationPart = {
     title?: string;
     content: PresentationContent;
 };
+/** The result of one `generate_analogy_report` call, as the tool gave it to the model: a report or an `extraction-failed` envelope. */
+export type AnalogyReportPart = {
+    type: "data-analogy-report";
+    /** The id of the tool call. */
+    id: string;
+    report: AnalogicalReasonerOutput;
+};
 export type PlanPart = {
     type: "data-plan";
     id: string;
@@ -498,8 +508,46 @@ export type ModelRetryPart = {
     /** The HTTP status of the failed attempt. Absent for a failure with no status, for example a lost connection. */
     status?: number;
 };
+/**
+ * A model request that the provider declined. `fallback`: another model answered the request, and `model` names it.
+ * `stopped`: no model answered, thus the reply of the request ended with the content filter.
+ */
+export type ModelRefusal = {
+    /** The id of the model response. */
+    id: string;
+    outcome: "fallback";
+    model: string;
+} | {
+    /** The id of the model response. */
+    id: string;
+    outcome: "stopped";
+};
+export type ModelRefusalPart = {
+    type: "data-model-refusal";
+} & ModelRefusal;
 /** The kind of a durable work, and of the work that a pause belongs to. A sub-agent belongs to its turn, and a sandbox step to its run. */
 export type WorkKind = "turn" | "run" | "profile";
+/**
+ * What waits in a pause. A sub-agent names its agent id, and a sandbox step names its step id. `synthesis` and `run`
+ * are the two stages of a run workflow that wait: the synthesis, and the charge gate before any step starts.
+ */
+export type PauseWaiter = {
+    readonly kind: "turn";
+} | {
+    readonly kind: "sub-agent";
+    readonly agentId: string;
+} | {
+    readonly kind: "step";
+    readonly stepId: string;
+} | {
+    readonly kind: "synthesis";
+} | {
+    readonly kind: "run";
+} | {
+    readonly kind: "profile";
+};
+/** How a wait ended: the deadline of `retrying`, the message of a resume, or a stop of the work. */
+export type PauseEnd = "retry" | "resume" | "abort";
 /**
  * The state of one waiting workflow of paused work. Re-emitted under the same `id` when the wait ends, with the
  * state `running`, so reconciling readers keep the latest state of each workflow.
@@ -511,17 +559,28 @@ export type PausePart = {
     /** The id of the work: the turn, the run, or the profile workflow. A resume names it. */
     workId: string;
     workKind: WorkKind;
-    /** `retrying`: the system sends the request again at `retryAt`. `paused`: only a resume ends the wait. */
+    /** What waits. Absent only for a wait that started before the harness recorded the waiter. */
+    waiter?: PauseWaiter;
+    /** `retrying`: the system sends the request again at `retryAt`. `paused`: only a resume ends the wait. `running`: the wait ended. */
     state: "retrying" | "paused" | "running";
-    /** Absent for the state `running`. */
-    cause?: PauseCause;
+    /** Why the work waited. The part that ends the wait keeps it. */
+    cause: PauseCause;
+    /** ISO 8601. The start of the wait. The part that ends the wait and a hold keep it. */
+    pausedAt: string;
     /** The count of timer retries before this wait. Absent for the state `running`. */
     attempt?: number;
     /** ISO 8601. Present for the state `retrying` only. */
     retryAt?: string;
+    /**
+     * ISO 8601. The time the wait ended. Present for the state `running` only. Absent when the replayed `pause.clear`
+     * step recorded no time.
+     */
+    endedAt?: string;
+    /** How the wait ended. Present for the state `running` only. */
+    end?: PauseEnd;
 };
 /** The parts whose contracts this version of the package declares — the arms the part registry knows. */
-export type KnownChatPart = PresentationPart | PlanPart | RunCardPart | PlanApprovalPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | ActivityEntryPart | SubAgentActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart | PausePart | ModelRetryPart;
+export type KnownChatPart = PresentationPart | AnalogyReportPart | PlanPart | RunCardPart | PlanApprovalPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | ActivityEntryPart | SubAgentActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart | PausePart | ModelRetryPart | ModelRefusalPart;
 /**
  * A part of a known contract, or a part whose type this build does not know. An emitter newer than this
  * build can lead the registry, and such a part already rides through the check boundary and the live view

package/dist/contracts/chat-parts.js

@@ -4,11 +4,13 @@
  *
  * Categories:
  *   Presentation:    data-presentation (agent-synthesized content),
- *                    data-plan (plan by id), data-file-reference (files by path)
+ *                    data-plan (plan by id), data-file-reference (files by path),
+ *                    data-analogy-report (the result of generate_analogy_report)
  *   Approval:        data-ask (a tool's pending user-approval prompt),
  *                    data-plan-approval (the record of an approved plan)
  *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Model retry:     data-model-retry (a retry of a model request inside the retry envelope of the provider)
+ *   Model refusal:   data-model-refusal (a model request that the provider declined)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree

package/dist/contracts/index.d.ts

@@ -2,7 +2,7 @@ export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel
 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, PlanApprovalPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, PlanGraphStep, DagStatePart, StepPhase, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, FindingReference, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, PauseCause, WorkKind, PausePart, ModelRetryPart, ChatPart, KnownChatPart, } from "./chat-parts.js";
+export type { PlanStep, PresentationContent, PresentationPart, AnalogyReportPart, PlanPart, RunCardPart, PlanApprovalPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, PlanGraphStep, DagStatePart, StepPhase, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, FindingReference, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, PauseCause, PauseWaiter, PauseEnd, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, ChatPart, KnownChatPart, } from "./chat-parts.js";
 export type { EventSource, TextDeltaEvent, IterationEvent, ToolStartedEvent, ToolFinishedEvent, ToolCallLeaf, ToolCallValue, FinishEvent, ChatErrorEvent, MessageStartEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";

package/dist/contracts/part-registry.js

@@ -1,5 +1,6 @@
 export const PART_REGISTRY = {
     "data-presentation": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
+    "data-analogy-report": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-plan": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-run-card": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-plan-approval": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
@@ -24,6 +25,7 @@ export const PART_REGISTRY = {
     "data-compaction": { emitter: "conversation", consumer: "conversation", transient: true, reconciling: true },
     "data-pause": { emitter: "workflow", consumer: "conversation", transient: false, reconciling: true },
     "data-model-retry": { emitter: "conversation", consumer: "conversation", transient: true, reconciling: true },
+    "data-model-refusal": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
 };
 export function isTransient(type) {
     return PART_REGISTRY[type].transient;

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

@@ -259,6 +259,7 @@ export declare const FinishEventSchema: z.ZodObject<{
         callPath: z.ZodArray<z.ZodString>;
         invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    finishReason: z.ZodString;
     usage: z.ZodOptional<z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
         outputTokens: z.ZodOptional<z.ZodNumber>;
@@ -484,6 +485,7 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         callPath: z.ZodArray<z.ZodString>;
         invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
+    finishReason: z.ZodString;
     usage: z.ZodOptional<z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
         outputTokens: z.ZodOptional<z.ZodNumber>;