@inflexa-ai/harness 0.48.3 → 0.48.4

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

@@ -93,6 +93,59 @@ export declare const PresentationPartSchema: z.ZodObject<{
         version: z.ZodNumber;
     }, z.core.$strip>], "kind">;
 }, z.core.$strip>;
+export declare const AnalogyReportPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-analogy-report">;
+    id: z.ZodString;
+    report: z.ZodUnion<readonly [z.ZodObject<{
+        problemSummary: z.ZodString;
+        problemObjects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+        }, z.core.$strip>>;
+        problemRelations: z.ZodArray<z.ZodString>;
+        keyTerms: z.ZodArray<z.ZodString>;
+        schemaVersion: z.ZodLiteral<"1">;
+        analogies: z.ZodArray<z.ZodObject<{
+            targetDomain: z.ZodString;
+            analogyTitle: z.ZodString;
+            objectMappings: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                rationale: z.ZodString;
+            }, z.core.$strip>>;
+            sharedRelations: z.ZodString;
+            coverage: z.ZodEnum<{
+                available: "available";
+                not_loaded: "not_loaded";
+                queried_no_data: "queried_no_data";
+                search_failed: "search_failed";
+            }>;
+            solutions: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                sourceDomain: z.ZodString;
+                description: z.ZodString;
+                keyConcepts: z.ZodArray<z.ZodString>;
+                relevance: z.ZodString;
+                sources: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    title: z.ZodString;
+                }, z.core.$strip>>;
+                githubRepos: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        error: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "extraction-failed": "extraction-failed";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
 export declare const PLAN_ID_RE: RegExp;
 export declare const PlanPartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-plan">;
@@ -600,6 +653,21 @@ export declare const PauseCauseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"host">;
     reason: z.ZodString;
 }, z.core.$strip>], "kind">;
+export declare const PauseWaiterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"turn">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sub-agent">;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    stepId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"synthesis">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"run">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"profile">;
+}, z.core.$strip>], "kind">;
 export declare const PausePartSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-pause">;
     id: z.ZodString;
@@ -609,21 +677,43 @@ export declare const PausePartSchema: z.ZodObject<{
         run: "run";
         turn: "turn";
     }>;
+    waiter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"turn">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sub-agent">;
+        agentId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"step">;
+        stepId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"synthesis">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"profile">;
+    }, z.core.$strip>], "kind">>;
     state: z.ZodEnum<{
         paused: "paused";
         retrying: "retrying";
         running: "running";
     }>;
-    cause: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"outage">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"credential">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"host">;
         reason: z.ZodString;
-    }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>], "kind">;
+    pausedAt: z.ZodString;
     attempt: z.ZodOptional<z.ZodNumber>;
     retryAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+    end: z.ZodOptional<z.ZodEnum<{
+        abort: "abort";
+        resume: "resume";
+        retry: "retry";
+    }>>;
 }, z.core.$strip>;
 /** Mirrors `ModelRefusalPart` without its `type`: the stored payload of the part. */
 export declare const ModelRefusalPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -720,6 +810,58 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         accession: z.ZodString;
         version: z.ZodNumber;
     }, z.core.$strip>], "kind">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-analogy-report">;
+    id: z.ZodString;
+    report: z.ZodUnion<readonly [z.ZodObject<{
+        problemSummary: z.ZodString;
+        problemObjects: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+        }, z.core.$strip>>;
+        problemRelations: z.ZodArray<z.ZodString>;
+        keyTerms: z.ZodArray<z.ZodString>;
+        schemaVersion: z.ZodLiteral<"1">;
+        analogies: z.ZodArray<z.ZodObject<{
+            targetDomain: z.ZodString;
+            analogyTitle: z.ZodString;
+            objectMappings: z.ZodArray<z.ZodObject<{
+                source: z.ZodString;
+                target: z.ZodString;
+                rationale: z.ZodString;
+            }, z.core.$strip>>;
+            sharedRelations: z.ZodString;
+            coverage: z.ZodEnum<{
+                available: "available";
+                not_loaded: "not_loaded";
+                queried_no_data: "queried_no_data";
+                search_failed: "search_failed";
+            }>;
+            solutions: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                sourceDomain: z.ZodString;
+                description: z.ZodString;
+                keyConcepts: z.ZodArray<z.ZodString>;
+                relevance: z.ZodString;
+                sources: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    title: z.ZodString;
+                }, z.core.$strip>>;
+                githubRepos: z.ZodArray<z.ZodObject<{
+                    url: z.ZodURL;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1">;
+        error: z.ZodObject<{
+            kind: z.ZodEnum<{
+                "extraction-failed": "extraction-failed";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"data-plan">;
     id: z.ZodString;
@@ -1087,21 +1229,43 @@ export declare const ChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         run: "run";
         turn: "turn";
     }>;
+    waiter: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"turn">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sub-agent">;
+        agentId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"step">;
+        stepId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"synthesis">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"run">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"profile">;
+    }, z.core.$strip>], "kind">>;
     state: z.ZodEnum<{
         paused: "paused";
         retrying: "retrying";
         running: "running";
     }>;
-    cause: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    cause: z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"outage">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"credential">;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"host">;
         reason: z.ZodString;
-    }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>], "kind">;
+    pausedAt: z.ZodString;
     attempt: z.ZodOptional<z.ZodNumber>;
     retryAt: z.ZodOptional<z.ZodString>;
+    endedAt: z.ZodOptional<z.ZodString>;
+    end: z.ZodOptional<z.ZodEnum<{
+        abort: "abort";
+        resume: "resume";
+        retry: "retry";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"data-model-retry">;
     id: z.ZodString;

package/dist/contracts/schemas/chat-parts.js

@@ -2,6 +2,7 @@
  * Zod schemas for chat data parts — validation at boundaries.
  */
 import { z } from "zod";
+import { AnalogicalReasonerOutputSchema } from "../analogy-report.js";
 import { ToolCallOutcomeSchema } from "./chat-events.js";
 import { TokenUsageRollupSchema } from "./usage.js";
 // ── Presentation ────────────────────────────────────────────────────
@@ -77,6 +78,12 @@ export const PresentationPartSchema = z.object({
     title: z.string().optional(),
     content: PresentationContentSchema,
 });
+// ── Analogy report ──────────────────────────────────────────────────
+export const AnalogyReportPartSchema = z.object({
+    type: z.literal("data-analogy-report"),
+    id: z.string(),
+    report: AnalogicalReasonerOutputSchema,
+});
 // ── Plan reference ──────────────────────────────────────────────────
 // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the issued plan-id shape: the pln- prefix plus 8 hex digits.
 export const PLAN_ID_RE = /^pln-[a-f0-9]{8}$/;
@@ -365,15 +372,27 @@ export const PauseCauseSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("credential") }),
     z.object({ kind: z.literal("host"), reason: z.string() }),
 ]);
+export const PauseWaiterSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("turn") }),
+    z.object({ kind: z.literal("sub-agent"), agentId: z.string() }),
+    z.object({ kind: z.literal("step"), stepId: z.string() }),
+    z.object({ kind: z.literal("synthesis") }),
+    z.object({ kind: z.literal("run") }),
+    z.object({ kind: z.literal("profile") }),
+]);
 export const PausePartSchema = z.object({
     type: z.literal("data-pause"),
     id: z.string(),
     workId: z.string(),
     workKind: z.enum(["turn", "run", "profile"]),
+    waiter: PauseWaiterSchema.optional(),
     state: z.enum(["retrying", "paused", "running"]),
-    cause: PauseCauseSchema.optional(),
+    cause: PauseCauseSchema,
+    pausedAt: z.string(),
     attempt: z.number().int().nonnegative().optional(),
     retryAt: z.string().optional(),
+    endedAt: z.string().optional(),
+    end: z.enum(["retry", "resume", "abort"]).optional(),
 });
 // ── Model refusal ───────────────────────────────────────────────────
 const ModelRefusalFallbackShape = { id: z.string(), outcome: z.literal("fallback"), model: z.string() };
@@ -413,6 +432,7 @@ export const SubAgentActivityPartSchema = z.object({
 // ── Union ───────────────────────────────────────────────────────────
 export const ChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
+    AnalogyReportPartSchema,
     PlanPartSchema,
     RunCardPartSchema,
     PlanApprovalPartSchema,

package/dist/index.d.ts

@@ -108,7 +108,7 @@ export type { SubAgentActivityTracker } from "./contracts/subagent-activity.js";
 export type { TextPart, ToolCallPart, MessagePart, ChatMessage } from "./contracts/message.js";
 export type { TurnTerminal, ApplyFrameResult, ChatPartCheck } from "./contracts/chat-frame.js";
 export type { TokenUsageRollup } from "./contracts/usage.js";
-export type { ChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, PlanApprovalPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, PlanGraphStep, StepStatus, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepUsagePart, StepBlockedPart, RunSynthesisPart, FindingReference, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, CompactionPart, PauseCause, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, AskPart, ChildSessionStartedPart, ReportRenderedPart, } from "./contracts/chat-parts.js";
+export type { ChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, PlanApprovalPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, PlanGraphStep, StepStatus, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepUsagePart, StepBlockedPart, RunSynthesisPart, FindingReference, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, CompactionPart, PauseCause, PauseWaiter, PauseEnd, WorkKind, PausePart, ModelRetryPart, ModelRefusal, ModelRefusalPart, AskPart, ChildSessionStartedPart, ReportRenderedPart, AnalogyReportPart, } from "./contracts/chat-parts.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
 export type { ChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./contracts/part-registry.js";
 export { parseStructureUrl, alphafoldEntryUrl, alphafoldPredictionUrl } from "./contracts/structure-source.js";

package/dist/lib/regulatory-corpus/fetch-ich.js

@@ -12,6 +12,7 @@
  * `ich-<code>` with non-word chars sanitized.
  */
 import { readPdfText } from "../pdf-text.js";
+import { slugify } from "../slug.js";
 import { normalizeWhitespace } from "./normalize-whitespace.js";
 /**
  * Curated catalog of ICH guidelines to index into the corpus.
@@ -157,19 +158,3 @@ export async function fetchAndExtractIchDoc(stub) {
         },
     };
 }
-function slugify(s) {
-    let out = "";
-    let inRun = false;
-    for (const char of s.toLowerCase()) {
-        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-        if (!isSlugChar) {
-            inRun = true;
-            continue;
-        }
-        if (inRun && out.length > 0)
-            out += "-";
-        inRun = false;
-        out += char;
-    }
-    return out;
-}

package/dist/lib/slug.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The shared lowercase slug: each run of characters outside `[a-z0-9]` becomes one dash.
+ *
+ * The helper holds the loop alone; each caller states its own cap and its own empty-result fallback beside
+ * the call.
+ */
+export type SlugifyOpts = {
+    /**
+     * The result never passes this length: the loop stops before the append that would cross it, and a
+     * final slice cuts a two-character append that straddled the cap. That slice keeps the dash, thus a
+     * capped result can end in a dash. A stop before an append cannot change the first characters of the
+     * result, because an append only extends the prefix.
+     */
+    maxLength?: number;
+    /** The result for an input with no slug character. Without a fallback the empty result stays empty. */
+    fallback?: string;
+};
+export declare function slugify(value: string, opts?: SlugifyOpts): string;

package/dist/lib/slug.js

@@ -0,0 +1,29 @@
+/**
+ * The shared lowercase slug: each run of characters outside `[a-z0-9]` becomes one dash.
+ *
+ * The helper holds the loop alone; each caller states its own cap and its own empty-result fallback beside
+ * the call.
+ */
+export function slugify(value, opts = {}) {
+    const { maxLength, fallback } = opts;
+    let out = "";
+    let inRun = false;
+    for (const char of value.toLowerCase()) {
+        if (maxLength !== undefined && out.length >= maxLength)
+            break;
+        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
+        if (!isSlugChar) {
+            inRun = true;
+            continue;
+        }
+        if (inRun && out.length > 0)
+            out += "-";
+        inRun = false;
+        out += char;
+    }
+    if (maxLength !== undefined && out.length > maxLength)
+        out = out.slice(0, maxLength);
+    if (out === "" && fallback !== undefined)
+        return fallback;
+    return out;
+}

package/dist/lib/test/pdf-fixture.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A minimal single-font PDF with one text line per page, `latin1`-encoded. It carries just enough structure
+ * for the PDF text extractors of the suites to read one body line per page.
+ */
+export declare function buildPdf(pageCount: number): Buffer;

package/dist/lib/test/pdf-fixture.js

@@ -0,0 +1,14 @@
+/**
+ * A minimal single-font PDF with one text line per page, `latin1`-encoded. It carries just enough structure
+ * for the PDF text extractors of the suites to read one body line per page.
+ */
+export function buildPdf(pageCount) {
+    const objects = ["1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj"];
+    const kids = Array.from({ length: pageCount }, (_, i) => `${4 + i * 2} 0 R`).join(" ");
+    objects.push(`2 0 obj<</Type/Pages/Kids[${kids}]/Count ${pageCount}>>endobj`, `3 0 obj<</Type/Font/Subtype/Type1/BaseFont/Helvetica>>endobj`);
+    for (let i = 0; i < pageCount; i++) {
+        const content = `BT /F1 12 Tf 72 720 Td (Page ${i + 1} body text) Tj ET`;
+        objects.push(`${4 + i * 2} 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 612 792]/Contents ${5 + i * 2} 0 R/Resources<</Font<</F1 3 0 R>>>>>>endobj`, `${5 + i * 2} 0 obj<</Length ${content.length}>>stream\n${content}\nendstream endobj`);
+    }
+    return Buffer.from(`%PDF-1.4\n${objects.join("\n")}\ntrailer<</Size ${3 + pageCount * 2}/Root 1 0 R>>`, "latin1");
+}

package/dist/loop/run-loop.js

@@ -526,6 +526,27 @@ async function runSeries(agent, opts, calls, log, target, spec) {
         const detail = computeDetail(tool, toolCall.input, log);
         return { detail: detail === undefined ? {} : { detail }, input: shownRoot ? viewInputValue(tool, toolCall.input, log) : undefined };
     };
+    /** The two events of a rejected tool call: the start names the call, and the finish states the outcome and the error text. */
+    const emitRejectedToolEvents = async (toolCall, shown, outcome, error) => {
+        await opts.emit({
+            type: "tool-started",
+            source,
+            toolUseId: toolCall.toolCallId,
+            name: toolCall.toolName,
+            ...shown.detail,
+            input: shown.input,
+        });
+        await opts.emit({
+            type: "tool-finished",
+            source,
+            toolUseId: toolCall.toolCallId,
+            name: toolCall.toolName,
+            outcome,
+            ...shown.detail,
+            input: shown.input,
+            error,
+        });
+    };
     const seriesSteps = [];
     let open = openStep();
     let failure;
@@ -561,24 +582,7 @@ async function runSeries(agent, opts, calls, log, target, spec) {
             if (refusal !== undefined) {
                 // A refused call does not run, thus its two events come from here.
                 const shown = callShownOf(toolCall);
-                await opts.emit({
-                    type: "tool-started",
-                    source,
-                    toolUseId: toolCall.toolCallId,
-                    name: toolCall.toolName,
-                    ...shown.detail,
-                    input: shown.input,
-                });
-                await opts.emit({
-                    type: "tool-finished",
-                    source,
-                    toolUseId: toolCall.toolCallId,
-                    name: toolCall.toolName,
-                    outcome: "error",
-                    ...shown.detail,
-                    input: shown.input,
-                    error: shownRoot ? textToolValue(refusal) : undefined,
-                });
+                await emitRejectedToolEvents(toolCall, shown, "error", shownRoot ? textToolValue(refusal) : undefined);
                 return { type: "denied", reason: refusal };
             }
             let denial;
@@ -595,23 +599,7 @@ async function runSeries(agent, opts, calls, log, target, spec) {
                 return undefined;
             deniedByTheUser.set(toolCall.toolCallId, denial);
             const shown = callShownOf(toolCall);
-            await opts.emit({
-                type: "tool-started",
-                source,
-                toolUseId: toolCall.toolCallId,
-                name: toolCall.toolName,
-                ...shown.detail,
-                input: shown.input,
-            });
-            await opts.emit({
-                type: "tool-finished",
-                source,
-                toolUseId: toolCall.toolCallId,
-                name: toolCall.toolName,
-                outcome: "denied",
-                ...shown.detail,
-                input: shown.input,
-            });
+            await emitRejectedToolEvents(toolCall, shown, "denied", undefined);
             return { type: "denied", reason: denial };
         },
         stopWhen: () => stops(),

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

@@ -18,7 +18,7 @@
  * runs the body of the sub-agent in its own process.
  */
 import type { RunSession } from "../auth/types.js";
-import type { WorkKind, PausePart } from "../contracts/chat-parts.js";
+import type { PauseWaiter, WorkKind, PausePart } from "../contracts/chat-parts.js";
 import type { ToolContext } from "../tools/define-tool.js";
 import type { LoopOptions } from "./run-loop.js";
 /** The options of the loop of a sub-agent that the place where it runs decides. */
@@ -48,7 +48,7 @@ export type SubAgentWork = {
     readonly runSession?: RunSession;
 };
 /** Gives the pause of the loops of a child, which writes its part through `emit`. The assembly gives it. */
-export type SubAgentPauses = (work: SubAgentWork, emit: (part: PausePart) => Promise<void>) => LoopOptions["pause"];
+export type SubAgentPauses = (work: SubAgentWork, waiter: PauseWaiter, emit: (part: PausePart) => Promise<void>) => LoopOptions["pause"];
 /**
  * Run a sub-agent in the process of its caller, with no workflow: its loops fold their usage into the total of the
  * caller. A tool factory that a test builds many times takes this registrar, because DBOS registers a name one time.

package/dist/loop/sub-agent.js

@@ -78,7 +78,7 @@ export function registerSubAgent(name, body, pauses) {
         const source = { agentId: name, callPath: [...caller.callPath, name] };
         const pause = pauses === undefined || work === undefined
             ? undefined
-            : pauses(work, async (part) => {
+            : pauses(work, { kind: "sub-agent", agentId: name }, async (part) => {
                 await writer.emit({ type: "data-pause", source, data: part });
             });
         // A recovered child replays its model calls, and the usage middleware adds each one again. Thus the total

package/dist/loop/test/metric-reader.d.ts

@@ -0,0 +1,9 @@
+import { type MetricData } from "@opentelemetry/sdk-metrics";
+export type MetricReader = {
+    /** Flush the provider and return the flat list of exported metrics. */
+    collect(): Promise<MetricData[]>;
+    /** Shut the provider down and unbind the global meter provider. */
+    stop(): Promise<void>;
+};
+/** Bind a meter provider over an in-memory exporter for one test; `stop` undoes both bindings after it. */
+export declare function metricReader(): MetricReader;

package/dist/loop/test/metric-reader.js

@@ -0,0 +1,33 @@
+import { metrics } from "@opentelemetry/api";
+import { AggregationTemporality, InMemoryMetricExporter, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { __resetMetricsForTest } from "../metrics.js";
+/** Bind a meter provider over an in-memory exporter for one test; `stop` undoes both bindings after it. */
+export function metricReader() {
+    const exporter = new InMemoryMetricExporter(AggregationTemporality.CUMULATIVE);
+    const provider = new MeterProvider({
+        readers: [
+            new PeriodicExportingMetricReader({
+                exporter,
+                // Long interval — every export in a suite is a manual flush.
+                exportIntervalMillis: 3_600_000,
+            }),
+        ],
+    });
+    metrics.setGlobalMeterProvider(provider);
+    // Drop memoized instruments so they rebind to this fresh provider.
+    __resetMetricsForTest();
+    return {
+        async collect() {
+            await provider.forceFlush();
+            return exporter
+                .getMetrics()
+                .flatMap((rm) => rm.scopeMetrics)
+                .flatMap((sm) => sm.metrics);
+        },
+        async stop() {
+            await provider.shutdown();
+            metrics.disable();
+            __resetMetricsForTest();
+        },
+    };
+}

package/dist/loop/test/unnamed-model.d.ts

@@ -0,0 +1,6 @@
+/**
+ * One ChatProvider whose stream answers one text delta and one finish that carries the given input-token
+ * total and no output tokens. The usage suites feed it to the loop and read the counters back.
+ */
+import type { ChatProvider } from "../../providers/types.js";
+export declare function unnamedModel(inputTokens: number): ChatProvider;

package/dist/loop/test/unnamed-model.js

@@ -0,0 +1,24 @@
+/**
+ * One ChatProvider whose stream answers one text delta and one finish that carries the given input-token
+ * total and no output tokens. The usage suites feed it to the loop and read the counters back.
+ */
+import { convertArrayToReadableStream, MockLanguageModelV4 } from "ai/test";
+import { createAiSdkProvider } from "../../providers/ai-sdk.js";
+export function unnamedModel(inputTokens) {
+    const parts = [
+        { type: "stream-start", warnings: [] },
+        { type: "text-start", id: "p0" },
+        { type: "text-delta", id: "p0", delta: "done" },
+        { type: "text-end", id: "p0" },
+        {
+            type: "finish",
+            finishReason: { unified: "stop", raw: "stop" },
+            usage: {
+                inputTokens: { total: inputTokens, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+                outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+            },
+        },
+    ];
+    const model = new MockLanguageModelV4({ provider: "unnamed", doStream: () => Promise.resolve({ stream: convertArrayToReadableStream(parts) }) });
+    return createAiSdkProvider({ model, maxRetries: 0 });
+}

package/dist/memory/conversation-display-recorder.d.ts

@@ -17,6 +17,8 @@ export type ConversationDisplayRecorder = {
     takeOpening(): ConversationUIMessage[];
     /** The assistant message of one round, when the recorder got parts after the last take, and the divider of a marker of the round. */
     takeRound(messages: readonly ModelMessage[]): ConversationUIMessage[];
+    /** The `data-pause` parts of the open round, in one assistant message with the id of the round, or none. The round stays open. */
+    openRoundPauses(): ConversationUIMessage[];
     /** The whole turn in one projection. `runChatTurn` stores each round with `takeOpening` and `takeRound` instead. */
     finish(options?: {
         readonly fallbackText?: string;

package/dist/memory/conversation-display-recorder.js

@@ -8,7 +8,7 @@ function jsonCopy(value) {
     return structuredClone(value);
 }
 const DURABLE_CONVERSATION_PART_TYPES = new Set(Object.entries(PART_REGISTRY)
-    .filter(([, descriptor]) => descriptor.emitter === "conversation" && descriptor.consumer === "conversation" && !descriptor.transient)
+    .filter(([, descriptor]) => descriptor.consumer === "conversation" && !descriptor.transient)
     .map(([type]) => type));
 function durableConversationType(type) {
     return DURABLE_CONVERSATION_PART_TYPES.has(type);
@@ -167,6 +167,10 @@ export function createConversationDisplayRecorder(options) {
         }
         return taken;
     }
+    function openRoundPauses() {
+        const parts = displayParts(roundParts().filter((part) => part.type === "data-pause"));
+        return parts.length === 0 ? [] : [{ id: assistantMessageId, role: "assistant", parts: jsonCopy(parts) }];
+    }
     function finish(finishOptions) {
         if (!finished) {
             finished = true;
@@ -187,5 +191,5 @@ export function createConversationDisplayRecorder(options) {
         }
         return messages;
     }
-    return { emit, observe, assistantMessageId: () => assistantMessageId, userMessageId: () => userMessageId, takeOpening, takeRound, finish };
+    return { emit, observe, assistantMessageId: () => assistantMessageId, userMessageId: () => userMessageId, takeOpening, takeRound, openRoundPauses, finish };
 }

package/dist/memory/conversation-display-storage.d.ts

@@ -15,7 +15,7 @@
  * reconstruction.
  */
 import { type DataUIPart, type UIMessage } from "ai";
-import type { AskPart, ChildSessionStartedPart, CompactionPart, FileReferencePart, ModelRefusal, ModelRefusalPart, PlanApprovalPart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart, SubAgentActivityEntry, SubAgentActivityPart } from "../contracts/chat-parts.js";
+import type { AnalogyReportPart, AskPart, ChildSessionStartedPart, CompactionPart, FileReferencePart, ModelRefusal, ModelRefusalPart, PausePart, PlanApprovalPart, PlanPart, PresentationPart, ReportRenderedPart, RunCardPart, SubAgentActivityEntry, SubAgentActivityPart } from "../contracts/chat-parts.js";
 import type { ToolCallOutcome } from "../contracts/chat-events.js";
 import type { ChatMessage, MessagePart, ToolCallPart } from "../contracts/message.js";
 import type { Logger } from "../lib/logger.js";
@@ -35,6 +35,7 @@ export type ConversationUIData = {
         outcome: ToolCallOutcome;
     };
     presentation: Payload<PresentationPart>;
+    "analogy-report": Payload<AnalogyReportPart>;
     plan: Payload<PlanPart>;
     "run-card": Payload<RunCardPart>;
     "plan-approval": Payload<PlanApprovalPart>;
@@ -44,6 +45,7 @@ export type ConversationUIData = {
     "report-rendered": Payload<ReportRenderedPart>;
     compaction: Payload<CompactionPart>;
     "model-refusal": ModelRefusal;
+    pause: Payload<PausePart>;
     "subagent-activity": Omit<Payload<SubAgentActivityPart>, "entries"> & {
         entries: (Omit<SubAgentActivityEntry, "outcome"> & {
             outcome: ToolCallOutcome;
@@ -66,7 +68,7 @@ export declare function parseStoredDisplayEnvelope(value: unknown, identity: str
 export type StoredSourcePart = Extract<Exclude<MessagePart, {
     type: "text";
 }>, {
-    type: ToolCallPart["type"] | PresentationPart["type"] | PlanPart["type"] | RunCardPart["type"] | PlanApprovalPart["type"] | FileReferencePart["type"] | AskPart["type"] | ChildSessionStartedPart["type"] | ReportRenderedPart["type"] | CompactionPart["type"] | ModelRefusalPart["type"] | SubAgentActivityPart["type"];
+    type: ToolCallPart["type"] | PresentationPart["type"] | AnalogyReportPart["type"] | PlanPart["type"] | RunCardPart["type"] | PlanApprovalPart["type"] | FileReferencePart["type"] | AskPart["type"] | ChildSessionStartedPart["type"] | ReportRenderedPart["type"] | CompactionPart["type"] | ModelRefusalPart["type"] | PausePart["type"] | SubAgentActivityPart["type"];
 }>;
 /** Whether `part` is an arm the stored vocabulary can hold; anything else cannot become a stored card. */
 export declare function isStoredSourcePart(part: Exclude<MessagePart, {