@inflexa-ai/harness 0.48.2 → 0.48.4

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.2",
+    "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"
     },