@inflexa-ai/harness 0.48.3 → 0.48.4

package/dist/state/data-profile.js

@@ -385,6 +385,24 @@ export function loadDataProfileStatus(pool, analysisId) {
         };
     });
 }
+/**
+ * The data profile that runs in an analysis, or in each analysis when `analysisId` is absent: the row is `running`
+ * and it names its workflow. A caller checks that the workflow is active.
+ */
+export function queryRunningProfiles(pool, analysisId) {
+    return tryQuery("dataProfile.queryRunningProfiles", async () => {
+        const result = await pool.query({
+            text: `SELECT analysis_id, data_profile_workflow_id
+            FROM cortex_analysis_state
+            WHERE ($1::text IS NULL OR analysis_id = $1)
+              AND data_profile_status = 'running'
+              AND data_profile_workflow_id IS NOT NULL
+            ORDER BY analysis_id`,
+            values: [analysisId ?? null],
+        });
+        return result.rows.map((row) => ({ analysisId: row.analysis_id, workflowId: row.data_profile_workflow_id }));
+    });
+}
 /**
  * Read an analysis's raw `seed_input_file_ids`, without the NULL-status collapse
  * {@link loadDataProfileStatus} applies (which hides the seed of any cleared row).

package/dist/state/index.d.ts

@@ -18,7 +18,7 @@ export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, up
 export type { InsertStepExecutionInput, RunStepCounts, SeedStepExecutionRow, UpdateStepExecutionInput } from "./step-executions.js";
 export { insertPlan, upsertPlan, loadPlan, loadPlanRecord, queryPlanPage } from "./plans.js";
 export type { InsertPlanInput, UpsertPlanInput, PlanRecord, PlanRowQuerier, PlanPage, PlanPageEntry } from "./plans.js";
-export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
+export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, queryRunningProfiles, recordDataProfileWorkflowId, } from "./data-profile.js";
 export type { DataProfileStatus, DataProfileTerminalWrite, DataProfileResult, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileDimension, DataProfileGroup, DataProfileGroupSlot, DataProfileFile, DataProfileMemberAnnotation, DataProfileObservation, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileKind, DataProfileAxis, DataProfileInputSignature, DataProfileCoverage, } from "./data-profile.js";
 export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfileStatusByAnalyses, queryLatestRunsByAnalyses, queryRunProgressByRuns, queryRunsEndedSince, } from "./analyses-metrics.js";
 export type { DataProfileSummary, EndedRunSummary, LatestRunSummary, RunProgressSummary } from "./analyses-metrics.js";

package/dist/state/index.js

@@ -13,7 +13,7 @@ export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollision
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, countRunsByAnalysis, queryRunsByThread, queryRunIdsByPlan, queryNewestPlanRun, } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun, countStepsByRuns, } from "./step-executions.js";
 export { insertPlan, upsertPlan, loadPlan, loadPlanRecord, queryPlanPage } from "./plans.js";
-export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
+export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, queryRunningProfiles, recordDataProfileWorkflowId, } from "./data-profile.js";
 export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfileStatusByAnalyses, queryLatestRunsByAnalyses, queryRunProgressByRuns, queryRunsEndedSince, } from "./analyses-metrics.js";
 // Not per-entity: one analysis's whole Postgres footprint, reached from its id
 // alone, with the workflow ledger behind an injected seam.

package/dist/state/migrations/20261102120000_record_the_waiter_of_a_pause.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A pause row names what waits. A row that a wait wrote before this column keeps a NULL waiter, which reads as no
+ * waiter, and the migration deletes no row.
+ */
+import type { Migration } from "kysely/migration";
+export declare const recordTheWaiterOfAPause: Migration;

package/dist/state/migrations/20261102120000_record_the_waiter_of_a_pause.js

@@ -0,0 +1,10 @@
+/**
+ * A pause row names what waits. A row that a wait wrote before this column keeps a NULL waiter, which reads as no
+ * waiter, and the migration deletes no row.
+ */
+import { sql } from "kysely";
+export const recordTheWaiterOfAPause = {
+    async up(db) {
+        await sql `ALTER TABLE cortex_paused_work ADD COLUMN IF NOT EXISTS waiter JSONB`.execute(db);
+    },
+};

package/dist/state/migrations/index.js

@@ -24,6 +24,7 @@ import { recordTheRunSessionOfAPause } from "./20261029120100_record_the_run_ses
 import { leaseTheSandboxes } from "./20261030120000_lease_the_sandboxes.js";
 import { dropTheReportDerivations } from "./20261030120100_drop_the_report_derivations.js";
 import { keepTheReportDerivations } from "./20261030120200_keep_the_report_derivations.js";
+import { recordTheWaiterOfAPause } from "./20261102120000_record_the_waiter_of_a_pause.js";
 export function cortexMigrations(logger) {
     return {
         "20260927120000_baseline": baseline(logger),
@@ -45,5 +46,6 @@ export function cortexMigrations(logger) {
         "20261030120000_lease_the_sandboxes": leaseTheSandboxes,
         "20261030120100_drop_the_report_derivations": dropTheReportDerivations,
         "20261030120200_keep_the_report_derivations": keepTheReportDerivations,
+        "20261102120000_record_the_waiter_of_a_pause": recordTheWaiterOfAPause,
     };
 }

package/dist/state/paused-work.d.ts

@@ -5,7 +5,7 @@
 import type { ResultAsync } from "neverthrow";
 import type { QueryConfig } from "pg";
 import type { RunSession } from "../auth/types.js";
-import type { PauseCause, WorkKind } from "../contracts/chat-parts.js";
+import type { PauseCause, PauseWaiter, WorkKind } from "../contracts/chat-parts.js";
 import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
 /** One waiting workflow, as its row records it. */
@@ -13,6 +13,8 @@ export type PauseRecord = {
     readonly workflowId: string;
     readonly workId: string;
     readonly workKind: WorkKind;
+    /** What waits. Absent for a row that a wait wrote before the waiter was recorded. */
+    readonly waiter?: PauseWaiter;
     readonly analysisId: string;
     readonly threadId?: string;
     readonly state: "retrying" | "paused";
@@ -46,7 +48,7 @@ export declare function clearPause(pool: Querier, workflowId: string): ResultAsy
 export declare function clearPauses(pool: Querier, workflowIds: readonly string[]): ResultAsync<void, DbError>;
 /** Delete the rows of each workflow of the work, for a stop of the work. */
 export declare function clearPausesOfWork(pool: Querier, workId: string): ResultAsync<void, DbError>;
-/** The rows of the paused work of an analysis, the oldest pause first. */
-export declare function queryPausesOfAnalysis(pool: PauseRowQuerier, analysisId: string): ResultAsync<PauseRecord[], DbError>;
+/** The rows of the paused work of an analysis, or of each analysis when `analysisId` is absent. The oldest pause is first. */
+export declare function queryPauses(pool: PauseRowQuerier, analysisId?: string): ResultAsync<PauseRecord[], DbError>;
 /** The rows of the waiting workflows of one work in an analysis. */
 export declare function queryPausesOfWork(pool: PauseRowQuerier, analysisId: string, workId: string): ResultAsync<PauseRecord[], DbError>;

package/dist/state/paused-work.js

@@ -3,6 +3,7 @@
  * before it waits and deletes it when the wait ends. A stop of the work deletes the rows of the work.
  */
 import { z } from "zod";
+import { PauseWaiterSchema } from "../contracts/schemas/chat-parts.js";
 import { tryMutation, tryQuery } from "../lib/db-result.js";
 const PauseCauseSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("outage") }),
@@ -13,6 +14,7 @@ const PauseRowSchema = z.object({
     workflow_id: z.string(),
     work_id: z.string(),
     work_kind: z.enum(["turn", "run", "profile"]),
+    waiter: PauseWaiterSchema.nullable(),
     analysis_id: z.string(),
     thread_id: z.string().nullable(),
     state: z.enum(["retrying", "paused"]),
@@ -33,13 +35,14 @@ const PauseRowSchema = z.object({
     })
         .nullable(),
 });
-const COLUMNS = "workflow_id, work_id, work_kind, analysis_id, thread_id, state, cause, attempt, retry_at, topic, paused_at, run_session";
+const COLUMNS = "workflow_id, work_id, work_kind, waiter, analysis_id, thread_id, state, cause, attempt, retry_at, topic, paused_at, run_session";
 function recordOf(row) {
     const parsed = PauseRowSchema.parse(row);
     return {
         workflowId: parsed.workflow_id,
         workId: parsed.work_id,
         workKind: parsed.work_kind,
+        waiter: parsed.waiter ?? undefined,
         analysisId: parsed.analysis_id,
         threadId: parsed.thread_id ?? undefined,
         state: parsed.state,
@@ -54,15 +57,16 @@ function recordOf(row) {
 /** Write the row of a waiting workflow. A workflow waits in one pause at a time, thus a new pause replaces its row. */
 export function recordPause(pool, record) {
     return tryMutation("pausedWork.record", () => pool.query(`INSERT INTO cortex_paused_work (${COLUMNS})
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
              ON CONFLICT (workflow_id) DO UPDATE SET
-               work_id = EXCLUDED.work_id, work_kind = EXCLUDED.work_kind, analysis_id = EXCLUDED.analysis_id,
+               work_id = EXCLUDED.work_id, work_kind = EXCLUDED.work_kind, waiter = EXCLUDED.waiter, analysis_id = EXCLUDED.analysis_id,
                thread_id = EXCLUDED.thread_id, state = EXCLUDED.state, cause = EXCLUDED.cause, attempt = EXCLUDED.attempt,
                retry_at = EXCLUDED.retry_at, topic = EXCLUDED.topic, paused_at = EXCLUDED.paused_at,
                run_session = EXCLUDED.run_session`, [
         record.workflowId,
         record.workId,
         record.workKind,
+        record.waiter === undefined ? null : JSON.stringify(record.waiter),
         record.analysisId,
         record.threadId ?? null,
         record.state,
@@ -86,10 +90,10 @@ export function clearPauses(pool, workflowIds) {
 export function clearPausesOfWork(pool, workId) {
     return tryMutation("pausedWork.clearWork", () => pool.query("DELETE FROM cortex_paused_work WHERE work_id = $1", [workId])).map(() => undefined);
 }
-/** The rows of the paused work of an analysis, the oldest pause first. */
-export function queryPausesOfAnalysis(pool, analysisId) {
-    return tryQuery("pausedWork.ofAnalysis", async () => {
-        const { rows } = await pool.query(`SELECT ${COLUMNS} FROM cortex_paused_work WHERE analysis_id = $1 ORDER BY paused_at, workflow_id`, [analysisId]);
+/** The rows of the paused work of an analysis, or of each analysis when `analysisId` is absent. The oldest pause is first. */
+export function queryPauses(pool, analysisId) {
+    return tryQuery("pausedWork.list", async () => {
+        const { rows } = await pool.query(`SELECT ${COLUMNS} FROM cortex_paused_work WHERE ($1::text IS NULL OR analysis_id = $1) ORDER BY paused_at, workflow_id`, [analysisId ?? null]);
         return rows.map(recordOf);
     });
 }

package/dist/state/runs.d.ts

@@ -99,9 +99,10 @@ export type RunTextFilter = {
  * in step: a new non-terminal status added to one and not the other makes a live run invisible to
  * exactly one of its readers.
  *
- * With `q`, only the runs that the text filter selects are members.
+ * With `q`, only the runs that the text filter selects are members. With no `analysisId`, the runs of each
+ * analysis are members, and each row names its analysis.
  */
-export declare function queryActiveRunsByAnalysis(pool: Querier, analysisId: string, { q }?: RunTextFilter): ResultAsync<CortexRunRow[], DbError>;
+export declare function queryActiveRunsByAnalysis(pool: Querier, analysisId: string | undefined, { q }?: RunTextFilter): ResultAsync<CortexRunRow[], DbError>;
 /**
  * How long a reserved run may wait for its workflow before {@link reconcileOrphanedRuns} fails it. A launch writes
  * the workflow row seconds after the reservation, and the margin covers a slow authorization gate of a managed host.

package/dist/state/runs.js

@@ -165,18 +165,19 @@ function runTextCondition(placeholder) {
  * in step: a new non-terminal status added to one and not the other makes a live run invisible to
  * exactly one of its readers.
  *
- * With `q`, only the runs that the text filter selects are members.
+ * With `q`, only the runs that the text filter selects are members. With no `analysisId`, the runs of each
+ * analysis are members, and each row names its analysis.
  */
 export function queryActiveRunsByAnalysis(pool, analysisId, { q } = {}) {
     return tryQuery("runs.queryActiveRunsByAnalysis", async () => {
-        const values = [analysisId];
+        const values = [analysisId ?? null];
         const text = q === undefined ? "" : `AND ${runTextCondition(`$${values.push(q)}`)}`;
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
                    mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
-            WHERE analysis_id = $1
+            WHERE ($1::text IS NULL OR analysis_id = $1)
               AND status = 'running'
               ${text}
             ORDER BY started_at DESC`,

package/dist/tasks/data-profile-index.js

@@ -21,6 +21,7 @@
  * `workspace_search` documents, so a consumer needs no id parsing to tell them apart.
  */
 import { presentFirst } from "../lib/present.js";
+import { slugify } from "../lib/slug.js";
 import { dimensionCardinalities, profileDimensions, profileFileRecords, profileGroups } from "../app/data-profile-view.js";
 /** Entity entries built for a legacy profile. Past this the entity tier is a liability, not a search aid. */
 export const MAX_ENTITY_ENTRIES = 20_000;
@@ -36,25 +37,10 @@ export const MAX_ENTITY_ENTRIES = 20_000;
 export const PROFILE_INDEX_TYPES = ["input-group", "input-dimension", "input", "input-kind"];
 /** Group names named in one legacy entity entry's text. */
 const MAX_GROUPS_IN_ENTITY_TEXT = 6;
+/** The profile entry slug: capped at 60 characters, and "unnamed" when the name holds no slug character. */
 function slug(value) {
-    let out = "";
-    let inRun = false;
-    for (const char of value.toLowerCase()) {
-        if (out.length >= SLUG_MAX_LENGTH)
-            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;
-    }
-    return out.slice(0, SLUG_MAX_LENGTH) || "unnamed";
+    return slugify(value, { maxLength: 60, fallback: "unnamed" });
 }
-const SLUG_MAX_LENGTH = 60;
 function slotSummary(slot) {
     return { id: slot.id, location: slot.location, tokenClass: slot.tokenClass, distinctValues: slot.distinctValues };
 }

package/dist/tasks/data-profile-resolve.js

@@ -18,6 +18,7 @@
  */
 import { assessCompleteness } from "../input-scan/companions.js";
 import { presentAt, presentFirst, presentGet } from "../lib/present.js";
+import { slugify } from "../lib/slug.js";
 import { buildSetMenu } from "../input-scan/menu.js";
 import { MAX_SLOT_SAMPLE_VALUES } from "../input-scan/tuning.js";
 import { dimensionScope } from "../contracts/profile-vocabulary.js";
@@ -35,25 +36,10 @@ export const UNCLASSIFIED_GROUP_ID = "unclassified";
 export const MAX_UNCLASSIFIED_RECIPE_PATHS = 1000;
 /** Contested paths named in the accounting before the count stands alone. */
 export const MAX_CONTESTED_SAMPLE = 10;
+/** The recipe group slug: capped at 60 characters, and "group" when the label holds no slug character. */
 function slug(value) {
-    let out = "";
-    let inRun = false;
-    for (const char of value.toLowerCase()) {
-        if (out.length >= SLUG_MAX_LENGTH)
-            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;
-    }
-    return out.slice(0, SLUG_MAX_LENGTH) || "group";
+    return slugify(value, { maxLength: 60, fallback: "group" });
 }
-const SLUG_MAX_LENGTH = 60;
 function fileCountOf(members) {
     return members.reduce((total, member) => total + 1 + member.companions.length, 0);
 }

package/dist/tasks/data-profile.js

@@ -418,6 +418,7 @@ export async function runDataProfileBody(input, deps) {
             pool: deps.pool,
             workId: workflowId,
             workKind: "profile",
+            waiter: { kind: "profile" },
             analysisId,
             emit: (part) => DBOS.writeStream("events", part),
             retryDelaysMs: deps.pauseRetryDelaysMs,

package/dist/tools/lib/opentargets-client.js

@@ -122,6 +122,10 @@ const BASELINE_EXPRESSION_PAGE_SIZE = 3000;
 // that resolves empty — an unknown/retired id yields `{"target": null}`, which a
 // bare `.optional()` rejects, turning a clean "not found" into a thrown error.
 const DatatypeScoreSchema = z.object({ id: z.string().optional(), score: z.number().optional() });
+/** The datatype-scores list follows the same nullable-optional reading rule as its row, and may be absent or null. */
+const scoresField = z.array(DatatypeScoreSchema).nullable().optional();
+/** The paged rows list of an association query: the API may omit or null the whole envelope. */
+const rowsEnvelope = (item) => z.object({ rows: z.array(item).nullable().optional() });
 export const TargetAssociationsDataSchema = z.object({
     target: z
         .object({
@@ -137,18 +141,11 @@ export const TargetAssociationsDataSchema = z.object({
         .optional(),
     associations: z
         .object({
-        associatedDiseases: z
-            .object({
-            rows: z
-                .array(z.object({
-                disease: z.object({ id: z.string(), name: z.string() }),
-                score: z.number(),
-                datatypeScores: z.array(DatatypeScoreSchema).nullable().optional(),
-            }))
-                .nullable()
-                .optional(),
-        })
-            .optional(),
+        associatedDiseases: rowsEnvelope(z.object({
+            disease: z.object({ id: z.string(), name: z.string() }),
+            score: z.number(),
+            datatypeScores: scoresField,
+        })).optional(),
     })
         .nullable()
         .optional(),
@@ -158,21 +155,14 @@ const DiseaseAssociationsDataSchema = z.object({
         .object({
         id: z.string().optional(),
         name: z.string().optional(),
-        associatedTargets: z
-            .object({
-            rows: z
-                .array(z.object({
-                target: z
-                    .object({ id: z.string().optional(), approvedSymbol: z.string().optional(), approvedName: z.string().optional() })
-                    .nullable()
-                    .optional(),
-                score: z.number(),
-                datatypeScores: z.array(DatatypeScoreSchema).nullable().optional(),
-            }))
+        associatedTargets: rowsEnvelope(z.object({
+            target: z
+                .object({ id: z.string().optional(), approvedSymbol: z.string().optional(), approvedName: z.string().optional() })
                 .nullable()
                 .optional(),
-        })
-            .optional(),
+            score: z.number(),
+            datatypeScores: scoresField,
+        })).optional(),
     })
         .nullable()
         .optional(),

package/dist/tools/report-authoring/authoring-tools.d.ts

@@ -34,9 +34,8 @@ import type { DraftDocument } from "../../report-model/draft.js";
 import type { ReportSnapshot } from "../../report-model/reference-resolver.js";
 import type { DerivationRecord } from "../../state/report-session-state.js";
 import { type Tool } from "../define-tool.js";
-/** The flat destination fields. An anchor is `before` or `after`, and a place is `start` or `end`. */
+/** The flat destination fields of the add, plus the payload of the new block. */
 declare const addBlockInput: z.ZodObject<{
-    block: z.ZodUnion<readonly [z.ZodType<import("../../report-model/authoring-grammar.js").AuthoringBlock, unknown, z.core.$ZodTypeInternals<import("../../report-model/authoring-grammar.js").AuthoringBlock, unknown>>, z.ZodUnknown]>;
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     place: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         end: "end";
@@ -44,6 +43,7 @@ declare const addBlockInput: z.ZodObject<{
     }>>>;
     before: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     after: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    block: z.ZodUnion<readonly [z.ZodType<import("../../report-model/authoring-grammar.js").AuthoringBlock, unknown, z.core.$ZodTypeInternals<import("../../report-model/authoring-grammar.js").AuthoringBlock, unknown>>, z.ZodUnknown]>;
 }, z.core.$strip>;
 /**
  * The change payload is a title for a section target, or a block for an atom target, and exactly one of
@@ -59,7 +59,6 @@ declare const removeBlockInput: z.ZodObject<{
     targetId: z.ZodString;
 }, z.core.$strip>;
 declare const moveBlockInput: z.ZodObject<{
-    targetId: z.ZodString;
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     place: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         end: "end";
@@ -67,6 +66,7 @@ declare const moveBlockInput: z.ZodObject<{
     }>>>;
     before: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     after: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    targetId: z.ZodString;
 }, z.core.$strip>;
 declare const readOutlineInput: z.ZodObject<{}, z.core.$strip>;
 /** The read names its target with the same field name as each mutation, thus one id key serves them all. */

package/dist/tools/report-authoring/authoring-tools.js

@@ -70,12 +70,16 @@ const DESTINATION_NOTES = {
     after: "The id of a sibling block. The block lands directly after it.",
 };
 /** The flat destination fields. An anchor is `before` or `after`, and a place is `start` or `end`. */
-const addBlockInput = z.object({
-    block: blockPayload,
+const destinationFields = {
     parentId: absentable(z.string()).describe(DESTINATION_NOTES.parentId),
     place: absentable(z.enum(["start", "end"])).describe(DESTINATION_NOTES.place),
     before: absentable(z.string()).describe(DESTINATION_NOTES.before),
     after: absentable(z.string()).describe(DESTINATION_NOTES.after),
+};
+/** The flat destination fields of the add, plus the payload of the new block. */
+const addBlockInput = z.object({
+    block: blockPayload,
+    ...destinationFields,
 });
 /**
  * The change payload is a title for a section target, or a block for an atom target, and exactly one of
@@ -92,10 +96,7 @@ const removeBlockInput = z.object({
 });
 const moveBlockInput = z.object({
     targetId: z.string().describe("The id of the block to move, as the outline gives it."),
-    parentId: absentable(z.string()).describe(DESTINATION_NOTES.parentId),
-    place: absentable(z.enum(["start", "end"])).describe(DESTINATION_NOTES.place),
-    before: absentable(z.string()).describe(DESTINATION_NOTES.before),
-    after: absentable(z.string()).describe(DESTINATION_NOTES.after),
+    ...destinationFields,
 });
 const readOutlineInput = z.object({});
 /** The read names its target with the same field name as each mutation, thus one id key serves them all. */

package/dist/tools/research/generate-analogy-report.js

@@ -260,7 +260,9 @@ export function createGenerateAnalogyReportTool(deps, registerSubAgent) {
             "drives a multi-step research sub-agent (up to 40 model turns) over live " +
             "literature search, so it is slow; a fact that one lookup answers does " +
             "not need it.\n" +
-            "RETURNS an AnalogyReport envelope the UI renders as an inline card. An " +
+            "RETURNS an AnalogyReport envelope. The analogy block shows the full " +
+            "report to the user, thus your reply names the analogies that matter by " +
+            "their `analogyTitle` and does not copy the report. An " +
             "analogy the search could not fill carries a `coverage` tag " +
             "(`queried_no_data` | `search_failed` | `not_loaded`) with an empty " +
             "`solutions` array — a partial result, not an error. A top-level `error` " +
@@ -273,7 +275,13 @@ export function createGenerateAnalogyReportTool(deps, registerSubAgent) {
         view: "none",
         describeCall: "none",
         startsWorkflow: true,
-        execute: async (input, ctx) => ok(await research(input, ctx)),
+        execute: async (input, ctx) => {
+            const report = await research(input, ctx);
+            // The execute runs in the body of the turn, where a stream write is checkpointed, thus a replay gives no second
+            // part. The root session keeps the part in the stored display, which drops each frame of a sub-agent.
+            await ctx.emit({ type: "data-analogy-report", source: ctx.session.provenance, data: { id: ctx.invocationId, report } });
+            return ok(report);
+        },
     });
 }
 /** The envelope of a run that recorded no outcome, also after its salvage. */

package/dist/workflows/execute-analysis.js

@@ -590,17 +590,18 @@ export async function runExecuteAnalysisBody(input, deps) {
     // the run authorization is already minted and rides in `input.runSession`.
     const runId = input.runSession.runFrame.runId;
     const workflowId = runId;
-    const pause = workPause({
+    const pauseAs = (waiter) => workPause({
         pool: deps.pool,
         workId: runId,
         workKind: "run",
+        waiter,
         analysisId: input.analysisId,
         emit: emitStreamPart,
         retryDelaysMs: deps.pauseRetryDelaysMs,
         run: { session: input.runSession, authorizer: deps.runAuthorizer },
         logger,
     });
-    const init = await validateAndInit(input, runId, deps, pause);
+    const init = await validateAndInit(input, runId, deps, pauseAs({ kind: "run" }));
     if (init.kind === "joined-existing") {
         return {
             runId: init.runId,
@@ -728,7 +729,7 @@ export async function runExecuteAnalysisBody(input, deps) {
                 completedSteps: [...final.completed],
                 session: input.runSession,
                 deps,
-                pause,
+                pause: pauseAs({ kind: "synthesis" }),
             });
             synthesisFindings = synthOut.findings;
             synthesisOutcome = { status: synthOut.synthesisStatus, reason: synthOut.synthesisReason };

package/dist/workflows/pause.d.ts

@@ -11,7 +11,7 @@
  * with the message of a resume, or with a stop. The server never sends that message by itself.
  */
 import type { RunSession } from "../auth/types.js";
-import type { PauseCause, WorkKind, PausePart } from "../contracts/chat-parts.js";
+import type { PauseCause, PauseEnd, PauseWaiter, WorkKind, PausePart } from "../contracts/chat-parts.js";
 import type { RunAuthorizer } from "../execution/run-authorizer.js";
 import type { Logger } from "../lib/logger.js";
 import type { Querier } from "../state/db.js";
@@ -29,14 +29,14 @@ export declare const HOLD_MESSAGE: {
 export declare function pauseTopic(pauseId: string): string;
 /** The cause of a pause in a failure, or `undefined` for a failure that no person or time can repair. */
 export declare function pauseCauseOf(failure: unknown): PauseCause | undefined;
-/** 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 work that a pause belongs to, and where the part of the pause goes. */
 export type PauseScope = {
     readonly pool: Querier;
     /** The turn id, the run id, or the id of the profile workflow. A sub-agent names its turn, and a step its run. */
     readonly workId: string;
     readonly workKind: WorkKind;
+    /** What waits in this workflow. */
+    readonly waiter: PauseWaiter;
     readonly analysisId: string;
     readonly threadId?: string;
     /** Writes the part of the pause to the stream of the work. */

package/dist/workflows/pause.js

@@ -96,10 +96,11 @@ export function workPause(scope) {
         const delayMs = cause.kind === "outage" ? delays[attempt] : undefined;
         const state = delayMs === undefined ? "paused" : "retrying";
         const pauseId = await DBOS.randomUUID();
-        const pausedAt = await DBOS.now();
-        const retryAt = delayMs === undefined ? undefined : new Date(pausedAt + delayMs).toISOString();
+        const pausedAtMs = await DBOS.now();
+        const pausedAt = new Date(pausedAtMs).toISOString();
+        const retryAt = delayMs === undefined ? undefined : new Date(pausedAtMs + delayMs).toISOString();
         const topic = pauseTopic(pauseId);
-        const work = { workId: scope.workId, workKind: scope.workKind };
+        const work = { workId: scope.workId, workKind: scope.workKind, waiter: scope.waiter };
         await DBOS.runStep(async () => unwrapOrThrow(await recordPause(scope.pool, {
             workflowId,
             ...work,
@@ -110,7 +111,7 @@ export function workPause(scope) {
             attempt,
             retryAt,
             topic,
-            pausedAt: new Date(pausedAt).toISOString(),
+            pausedAt,
             runSession: scope.run?.session,
         })), { name: "pause.record" });
         // Only a person ends a wait in `paused`, thus the credential stops until the renewal of the resume.
@@ -122,7 +123,7 @@ export function workPause(scope) {
         };
         if (state === "paused")
             await suspendCredential("pause.suspend");
-        await scope.emit({ type: "data-pause", id: workflowId, ...work, state, cause, attempt, retryAt });
+        await scope.emit({ type: "data-pause", id: workflowId, ...work, state, cause, pausedAt, attempt, retryAt });
         log.warn("work paused", { workflowId, ...work, state, cause: cause.kind, attempt });
         let end;
         const untrack = trackWorkPaused({ workKind: scope.workKind });
@@ -139,11 +140,11 @@ export function workPause(scope) {
                     cause,
                     attempt,
                     topic,
-                    pausedAt: new Date(pausedAt).toISOString(),
+                    pausedAt,
                     runSession: scope.run?.session,
                 })), { name: "pause.hold" });
                 await suspendCredential("pause.hold.suspend");
-                await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "paused", cause, attempt });
+                await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "paused", cause, pausedAt, attempt });
                 log.info("work held", { workflowId, ...work, attempt });
                 const held = await waitForMessage(topic, undefined, signal);
                 end = held === "hold" ? "resume" : held;
@@ -155,8 +156,13 @@ export function workPause(scope) {
         finally {
             untrack();
         }
-        await DBOS.runStep(async () => unwrapOrThrow(await clearPause(scope.pool, workflowId)), { name: "pause.clear" });
-        await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "running" });
+        // The time is read inside the step, thus a recovery replays the recorded time and the end keeps one time.
+        // The replayed step output is `undefined` when the recorded step has no time.
+        const endedAt = await DBOS.runStep(async () => {
+            unwrapOrThrow(await clearPause(scope.pool, workflowId));
+            return new Date().toISOString();
+        }, { name: "pause.clear" });
+        await scope.emit({ type: "data-pause", id: workflowId, ...work, state: "running", cause, pausedAt, endedAt, end });
         log.info("pause ended", { workflowId, ...work, end });
         return end;
     };

package/dist/workflows/sandbox-step.js

@@ -157,6 +157,7 @@ export async function runSandboxStepBody(input, deps) {
         pool: deps.pool,
         workId: input.runId,
         workKind: "run",
+        waiter: { kind: "step", stepId: input.stepId },
         analysisId: input.analysisId,
         emit: safeEmit,
         retryDelaysMs: deps.pauseRetryDelaysMs,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.48.3",
+    "version": "0.48.4",
     "description": "Host-agnostic bioinformatics agent harness — an agent loop on the AI SDK, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -37,8 +37,10 @@
         "build": "tsc -p tsconfig.build.json && node scripts/copy-assets.mjs",
         "design:fixture": "bun scripts/render-fixture.ts",
         "design:gallery": "bun scripts/render-gallery.ts",
-        "format": "prettier --write src/",
-        "format:file": "prettier --write",
+        "dupes": "jscpd src scripts --exit-code --fail-on-empty",
+        "format": "oxfmt src/",
+        "format:check": "oxfmt --check src/",
+        "format:file": "oxfmt",
         "gallery:data": "bash scripts/gallery-data.sh",
         "lint": "bun --bun oxlint",
         "lint:python": "ruff check src/input-scan/decoder && ruff format --check src/input-scan/decoder",
@@ -119,9 +121,10 @@
         "@typescript/native": "npm:typescript@7.0.2",
         "csstree-validator": "^4.0.1",
         "html-validate": "^11.6.2",
+        "jscpd": "5.4.2",
+        "oxfmt": "0.71.0",
         "oxlint": "1.85.0",
         "oxlint-tsgolint": "7.0.2003",
-        "prettier": "^3.9.5",
         "testcontainers": "^10.28.0",
         "typescript": "^6.0.3"
     },