@inflexa-ai/harness 0.44.0 → 0.45.0

package/dist/tools/execute-analysis.js

@@ -3,7 +3,7 @@
  * hoc analyses. Both modes launch the ordinary executeAnalysis workflow.
  */
 import { randomUUID } from "node:crypto";
-import { err, ok } from "neverthrow";
+import { err, ok, ResultAsync } from "neverthrow";
 import { z } from "zod";
 import { SANDBOX_AGENT_META } from "../agents/sandbox/index.js";
 import { DEFAULT_SANDBOX_MAX_STEPS } from "../config/resource-limits.js";
@@ -103,9 +103,9 @@ export class PlanPackagesMissingError extends Error {
  * is what the launch record must carry to tell a checked launch from an
  * unchecked one.
  */
-async function linkPlanPackages(extendAnalysisFarm, analysisId, plan) {
+async function linkPlanPackages(extendAnalysisFarm, analysisId, planId, plan) {
     if (!extendAnalysisFarm)
-        return 0;
+        return ok(0);
     // The union dedupes EQUAL queries only: two entries are one ask when their
     // spelling, their track, and their version are equal. A bare entry beside a
     // qualified entry of one spelling stays two asks, because the bare one
@@ -118,7 +118,12 @@ async function linkPlanPackages(extendAnalysisFarm, analysisId, plan) {
             if (parsed.isErr()) {
                 // `validatePlan` parsed every entry of this plan already, thus a
                 // refusal here means that the two readers disagree.
-                throw new Error(`Step "${step.id}" carries the package entry "${entry}", which the plan validation should have refused`);
+                return err({
+                    type: "plan_invalid",
+                    planId,
+                    malformed: false,
+                    errors: [`Step "${step.id}" carries the package entry "${entry}", which the plan validation should have refused`],
+                });
             }
             const query = parsed.value;
             const key = formatQuery(query);
@@ -128,12 +133,12 @@ async function linkPlanPackages(extendAnalysisFarm, analysisId, plan) {
     }
     const queries = [...union.values()];
     if (queries.length === 0)
-        return 0;
+        return ok(0);
     const linked = await callExtendAnalysisFarm(extendAnalysisFarm, analysisId, queries);
     if (linked.isErr()) {
         // A call that gave no answer is an `unavailable` answer, not a driver
         // error: the planner can act on "the store cannot answer".
-        throw new PlanPackagesMissingError([], [], linked.error);
+        return err({ type: "packages_missing", missing: [], collisions: [], unavailable: linked.error });
     }
     const outcomes = linked.value;
     // An `unavailable` outcome preempts everything: the link pass could not
@@ -141,7 +146,7 @@ async function linkPlanPackages(extendAnalysisFarm, analysisId, plan) {
     // absence list would be a fabrication. One reason covers the batch.
     const unavailable = outcomes.find((o) => o.kind === "unavailable");
     if (unavailable !== undefined) {
-        throw new PlanPackagesMissingError([], [], unavailable.reason);
+        return err({ type: "packages_missing", missing: [], collisions: [], unavailable: unavailable.reason });
     }
     // A seam-supplied detail classifies the miss in host terms (in flight,
     // failed with its reason, never requested), and it rides beside the name
@@ -165,13 +170,32 @@ async function linkPlanPackages(extendAnalysisFarm, analysisId, plan) {
         `; when the two directories are one spelling in two tracks, name the track in the plan, as ` +
         `${formatQuery({ spelling: o.spelling, track: "python" })} or ${formatQuery({ spelling: o.spelling, track: "r" })}`);
     if (missing.length > 0 || collisions.length > 0) {
-        throw new PlanPackagesMissingError(missing, collisions);
+        return err({ type: "packages_missing", missing, collisions });
     }
-    return queries.length;
+    return ok(queries.length);
 }
 function planSummary(plan) {
     return plan.title?.trim() || plan.analytical_narrative.trim().slice(0, 280);
 }
+/**
+ * The resources of each step. `validatePlan` refuses a step without them, thus
+ * a missing entry here means that the two readers disagree.
+ */
+function stepResources(planId, plan) {
+    const byStepId = {};
+    for (const step of plan.steps) {
+        if (!step.resources) {
+            return err({
+                type: "plan_invalid",
+                planId,
+                malformed: false,
+                errors: [`Step "${step.id}" has no resources — validation should have rejected it`],
+            });
+        }
+        byStepId[step.id] = step.resources;
+    }
+    return ok(byStepId);
+}
 function workflowInput(planId, plan, args) {
     return {
         analysisId: args.analysisId,
@@ -181,11 +205,7 @@ function workflowInput(planId, plan, args) {
         steps: plan.steps.map((step) => ({ id: step.id, depends_on: step.depends_on ?? [] })),
         planStepById: Object.fromEntries(plan.steps.map((step) => [step.id, step])),
         agentByStepId: Object.fromEntries(plan.steps.map((step) => [step.id, step.agent ?? "unknown"])),
-        resourcesByStepId: Object.fromEntries(plan.steps.map((step) => {
-            if (!step.resources)
-                throw new Error(`Step "${step.id}" has no resources — validation should have rejected it`);
-            return [step.id, step.resources];
-        })),
+        resourcesByStepId: args.resourcesByStepId,
         timeoutByStepId: Object.fromEntries(plan.steps.filter((step) => step.timeout !== undefined).map((step) => [step.id, step.timeout])),
         budget: args.budget,
         runSession: args.runSession,
@@ -193,14 +213,21 @@ function workflowInput(planId, plan, args) {
         synthesisEnabled: args.synthesisEnabled,
     };
 }
-function validateStoredPlan(raw, planId) {
+function parseStoredPlan(raw, planId) {
     const parsed = AnalysisPlanSchema.safeParse(raw);
     if (!parsed.success)
-        throw new PlanMalformedError(planId);
+        return err({ type: "plan_invalid", planId, malformed: true, errors: [] });
     const result = validatePlan(parsed.data);
     if (!result.valid)
-        throw new PlanValidationError(planId, result.errors);
-    return parsed.data;
+        return err({ type: "plan_invalid", planId, malformed: false, errors: result.errors });
+    return ok(parsed.data);
+}
+/** The error that a tool body throws for a stored plan that the parse refused. */
+function validateStoredPlan(raw, planId) {
+    const parsed = parseStoredPlan(raw, planId);
+    if (parsed.isErr())
+        return throwLaunchRefusal(parsed.error);
+    return parsed.value;
 }
 function adHocTitle(request) {
     const compact = request.trim().replace(/\s+/g, " ");
@@ -320,8 +347,181 @@ async function persistedAdHocPlan(deps, args) {
         throw new Error(`Internal ad hoc plan ${args.planId} could not be reloaded`);
     return validateStoredPlan(stored, args.planId);
 }
-export function createExecuteAnalysisTool(deps) {
+/**
+ * The half of a launch that the plan mode and the ad hoc mode share: the link pass, the reservation,
+ * the authorization, and the workflow start. It gives each outcome as a `Result`.
+ */
+async function launchReservedRun(deps, args) {
     const logger = (deps.logger ?? createNoopLogger()).named("execute-analysis-tool");
+    const { session, planId, plan } = args;
+    const analysisId = session.scope.analysisId;
+    const threadId = session.scope.threadId ?? null;
+    const resources = stepResources(planId, plan);
+    if (resources.isErr())
+        return err(resources.error);
+    // The link pass comes before the run reserves anything, thus a pool
+    // miss leaves no run row and no revoked authorization behind.
+    const linked = await linkPlanPackages(deps.extendAnalysisFarm, analysisId, planId, plan);
+    if (linked.isErr())
+        return err(linked.error);
+    const packageQueries = linked.value;
+    const reservation = await args.reserve({ analysisId, threadId });
+    if (reservation.isErr())
+        return err(reservation.error);
+    if (!reservation.value.started)
+        return reservation;
+    const runId = reservation.value.runId;
+    const authorized = await passGate("RunAuthorizer.authorize", deps.runAuthorizer.authorize({
+        auth: session.auth,
+        scope: session.scope,
+        provenance: session.provenance,
+        frame: { runId },
+    }));
+    if (authorized.isErr()) {
+        // The refusal ends the run before a workflow exists, thus the
+        // reserved row must not stay `running`.
+        const { kind, reason } = authorized.error;
+        if (kind === "suspended") {
+            await updateRunStatus(deps.pool, runId, "suspended_insufficient_funds", reason).match(() => { }, () => { });
+            const suspension = await suspendAnalysis(deps.pool, analysisId);
+            if (suspension.isErr())
+                return err({ type: "store_failed", cause: suspension.error });
+            return err({ type: "suspended", reason });
+        }
+        await updateRunStatus(deps.pool, runId, "failed", reason).match(() => { }, () => { });
+        return err({ type: "not_authorized", reason });
+    }
+    const authorization = authorized.value;
+    const wfInput = workflowInput(planId, plan, {
+        analysisId,
+        threadId,
+        runSession: authorization.runSession,
+        ownsMandate: authorization.ownsMandate,
+        budget: deps.resourcePolicy?.budget,
+        synthesisEnabled: args.mode === "plan",
+        resourcesByStepId: resources.value,
+    });
+    try {
+        await deps.runLauncher.launch(deps.executeAnalysisWorkflow, { workflowId: runId }, wfInput);
+    }
+    catch (cause) {
+        await deliverNotice(logger, "RunAuthorizer.revoke", deps.runAuthorizer.revoke(authorization, "workflow-start-failed"));
+        // A failed write leaves the row `running` with no workflow. The boot repair (`reconcileOrphanedRuns`) fails it.
+        await updateRunStatus(deps.pool, runId, "failed", "workflow start failed").match(() => { }, (error) => logger.warn("the failed status of a run whose start failed was not written", { runId, ...logger.errorFields(error) }));
+        return err({ type: "launch_failed", cause });
+    }
+    logger.info("analysis launched", { analysisId, runId, planId, mode: args.mode, packageQueries });
+    return ok({ runId, started: true });
+}
+/**
+ * Reserve a fresh run for a plan. A concurrent launch of the same plan holds the active-plan slot,
+ * and its run is the answer.
+ */
+async function reservePlanRun(deps, args) {
+    const runId = randomUUID();
+    try {
+        const inserted = await insertRun(deps.pool, {
+            runId,
+            analysisId: args.analysisId,
+            threadId: args.threadId,
+            workflowName: "executeAnalysis",
+            planId: args.planId,
+        });
+        if (inserted.isErr())
+            return err({ type: "store_failed", cause: inserted.error });
+        return ok({ runId, started: true });
+    }
+    catch (cause) {
+        // `insertRun` rejects its promise on a collision of the active-plan index, and on nothing else.
+        if (!isDedupCollision(cause))
+            return err({ type: "store_failed", cause });
+        const active = await queryActiveRun(deps.pool, args.analysisId, args.planId);
+        if (active.isErr())
+            return err({ type: "store_failed", cause: active.error });
+        // The slot was free again when the read ran, so no run holds it and the collision stays the cause.
+        if (!active.value)
+            return err({ type: "store_failed", cause });
+        return ok({ runId: active.value.runId, started: false });
+    }
+}
+/**
+ * Reserve the run of an ad hoc call under its deterministic id, and treat a reservation that exists
+ * as a redelivery of the same call.
+ */
+async function reserveAdHocRun(deps, args) {
+    try {
+        const reservation = await reserveRunById(deps.pool, {
+            runId: args.runId,
+            analysisId: args.analysisId,
+            threadId: args.threadId,
+            workflowName: "executeAnalysis",
+            planId: args.planId,
+        });
+        if (reservation.isErr())
+            return err({ type: "store_failed", cause: reservation.error });
+        return ok({ runId: reservation.value.row.runId, started: reservation.value.inserted });
+    }
+    catch (cause) {
+        // `reserveRunById` rejects its promise when the run id belongs to another analysis.
+        return err({ type: "store_failed", cause });
+    }
+}
+async function launchStoredPlan(deps, input) {
+    const { session, planId } = input;
+    const analysisId = session.scope.analysisId;
+    const raw = await loadPlan(deps.pool, planId, { analysisId });
+    if (raw.isErr())
+        return err({ type: "store_failed", cause: raw.error });
+    if (!raw.value)
+        return err({ type: "plan_not_found", planId });
+    const plan = parseStoredPlan(raw.value, planId);
+    if (plan.isErr())
+        return err(plan.error);
+    const active = await queryActiveRun(deps.pool, analysisId, planId);
+    if (active.isErr())
+        return err({ type: "store_failed", cause: active.error });
+    if (active.value)
+        return ok({ runId: active.value.runId, started: false });
+    return launchReservedRun(deps, {
+        session,
+        planId,
+        plan: plan.value,
+        mode: "plan",
+        reserve: (frame) => reservePlanRun(deps, { ...frame, planId }),
+    });
+}
+/**
+ * Start the run of a stored plan. It reads the plan under the analysis of the session, validates it,
+ * links its packages, reserves a run, authorizes it, and starts the workflow. It gives the run id, or
+ * the refusal, and it emits no chat part. `started` is false when a run of the plan was already active.
+ *
+ * This is an API boundary: a host calls it outside a tool body, thus no outcome above rejects the
+ * promise.
+ */
+export function launchPlanRun(deps, input) {
+    return new ResultAsync(launchStoredPlan(deps, input));
+}
+/** Throw the error that the tool body threw before the launch gave a `Result`. */
+function throwLaunchRefusal(refusal) {
+    switch (refusal.type) {
+        case "plan_not_found":
+            throw new PlanNotFoundError(refusal.planId);
+        case "plan_invalid":
+            throw refusal.malformed ? new PlanMalformedError(refusal.planId) : new PlanValidationError(refusal.planId, refusal.errors);
+        case "packages_missing":
+            throw new PlanPackagesMissingError(refusal.missing, refusal.collisions, refusal.unavailable);
+        case "store_failed":
+            return unwrapOrThrow(err(refusal.cause));
+        case "launch_failed":
+            // The cause is the value that the launcher threw, and the tool rethrows it unchanged.
+            throw refusal.cause;
+        default: {
+            const unreachable = refusal;
+            return unreachable;
+        }
+    }
+}
+export function createExecuteAnalysisTool(deps) {
     return defineTool({
         id: "execute_analysis",
         description: "Launch analysis computation asynchronously. Use mode=plan with the planId only after the user approved that stored plan. " +
@@ -340,104 +540,36 @@ export function createExecuteAnalysisTool(deps) {
             if (!ctx.session.auth)
                 throw new Error("execute_analysis: session is missing its auth capability");
             const analysisId = ctx.session.scope.analysisId;
-            const threadId = ctx.session.scope.threadId ?? null;
             const planId = input.mode === "plan" ? input.planId : adHocPlanId(analysisId, ctx.invocationId);
             const emitRunCard = async (runId) => {
                 const card = await buildRunCardData(deps.pool, { planId, analysisId, runId }).unwrapOr(null);
                 if (card)
                     await ctx.emit({ type: "data-run-card", source: ctx.session.provenance, data: card });
             };
-            let plan;
-            if (input.mode === "plan") {
-                const raw = unwrapOrThrow(await loadPlan(deps.pool, planId, { analysisId }));
-                if (!raw)
-                    throw new PlanNotFoundError(planId);
-                plan = validateStoredPlan(raw, planId);
-                const active = unwrapOrThrow(await queryActiveRun(deps.pool, analysisId, planId));
-                if (active) {
-                    await emitRunCard(active.runId);
-                    return ok({ runId: active.runId, status: "in_progress" });
-                }
-            }
-            else {
-                plan = await persistedAdHocPlan(deps, { analysisId, request: input.request, ctx, planId });
-            }
-            // The link pass comes before the run reserves anything, thus a pool
-            // miss leaves no run row and no revoked authorization behind.
-            const packageQueries = await linkPlanPackages(deps.extendAnalysisFarm, analysisId, plan);
-            const runId = input.mode === "plan" ? randomUUID() : adHocRunId(analysisId, ctx.invocationId);
-            if (input.mode === "plan") {
-                try {
-                    unwrapOrThrow(await insertRun(deps.pool, {
-                        runId,
-                        analysisId,
-                        threadId,
-                        workflowName: "executeAnalysis",
-                        planId,
-                    }));
-                }
-                catch (error) {
-                    if (isDedupCollision(error)) {
-                        const active = unwrapOrThrow(await queryActiveRun(deps.pool, analysisId, planId));
-                        if (active) {
-                            await emitRunCard(active.runId);
-                            return ok({ runId: active.runId, status: "in_progress" });
-                        }
-                    }
-                    throw error;
-                }
-            }
-            else {
-                const reservation = unwrapOrThrow(await reserveRunById(deps.pool, {
-                    runId,
-                    analysisId,
-                    threadId,
-                    workflowName: "executeAnalysis",
+            const launch = async () => {
+                if (input.mode === "plan")
+                    return launchPlanRun(deps, { session: ctx.session, planId });
+                const plan = await persistedAdHocPlan(deps, { analysisId, request: input.request, ctx, planId });
+                const runId = adHocRunId(analysisId, ctx.invocationId);
+                return launchReservedRun(deps, {
+                    session: ctx.session,
                     planId,
-                }));
-                if (!reservation.inserted) {
-                    await emitRunCard(reservation.row.runId);
-                    return ok({ runId: reservation.row.runId, status: "in_progress" });
-                }
-            }
-            const authorized = await passGate("RunAuthorizer.authorize", deps.runAuthorizer.authorize({
-                auth: ctx.session.auth,
-                scope: ctx.session.scope,
-                provenance: ctx.session.provenance,
-                frame: { runId },
-            }));
-            if (authorized.isErr()) {
-                // The refusal ends the run before a workflow exists, thus the
-                // reserved row must not stay `running`.
-                const { kind, reason } = authorized.error;
-                if (kind === "suspended") {
-                    await updateRunStatus(deps.pool, runId, "canceled", reason).match(() => { }, () => { });
-                    unwrapOrThrow(await suspendAnalysis(deps.pool, analysisId));
-                    return err({ error: `The analysis is suspended: ${reason}`, retryable: false });
-                }
-                await updateRunStatus(deps.pool, runId, "failed", reason).match(() => { }, () => { });
-                return err({ error: `The run was not authorized: ${reason}`, retryable: false });
-            }
-            const authorization = authorized.value;
-            const wfInput = workflowInput(planId, plan, {
-                analysisId,
-                threadId,
-                runSession: authorization.runSession,
-                ownsMandate: authorization.ownsMandate,
-                budget: deps.resourcePolicy?.budget,
-                synthesisEnabled: input.mode === "plan",
-            });
-            try {
-                await deps.runLauncher.launch(deps.executeAnalysisWorkflow, { workflowId: runId }, wfInput);
-            }
-            catch (error) {
-                await deliverNotice(logger, "RunAuthorizer.revoke", deps.runAuthorizer.revoke(authorization, "workflow-start-failed"));
-                await updateRunStatus(deps.pool, runId, "failed", "workflow start failed").match(() => { }, () => { });
-                throw error;
+                    plan,
+                    mode: "adhoc",
+                    reserve: (frame) => reserveAdHocRun(deps, { ...frame, planId, runId }),
+                });
+            };
+            const launched = await launch();
+            if (launched.isErr()) {
+                const refusal = launched.error;
+                if (refusal.type === "suspended")
+                    return err({ error: `The analysis is suspended: ${refusal.reason}`, retryable: false });
+                if (refusal.type === "not_authorized")
+                    return err({ error: `The run was not authorized: ${refusal.reason}`, retryable: false });
+                return throwLaunchRefusal(refusal);
             }
-            logger.info("analysis launched", { analysisId, runId, planId, mode: input.mode, packageQueries });
-            await emitRunCard(runId);
-            return ok({ runId, status: "in_progress" });
+            await emitRunCard(launched.value.runId);
+            return ok({ runId: launched.value.runId, status: "in_progress" });
         },
     });
 }

package/dist/tools/research/inspect-data-profile.d.ts

@@ -161,7 +161,7 @@ interface FailedOutput {
 }
 export type InspectDataProfileOutput = OverviewOutput | GroupsOutput | FilesOutput | AbsentOutput | PendingOutput | FailedOutput;
 export declare function createInspectDataProfileTool(pool: Pool): import("../define-tool.js").Tool<{
-    scope?: "overview" | "groups" | "files" | undefined;
+    scope?: "groups" | "files" | "overview" | undefined;
     page?: number | undefined;
     pageSize?: number | undefined;
 }, InspectDataProfileOutput>;

package/dist/tools/research/inspect-run.d.ts

@@ -2,7 +2,7 @@
  * inspectRun — inspect workflow runs for the current analysis.
  *
  * Results are pull-only: workflows never append completion messages to a
- * conversation. List mode is active-first and paged. Targeted mode makes
+ * conversation. List mode puts the running runs first and is paged. Targeted mode makes
  * readiness explicit and can perform one bounded, abort-aware wait.
  */
 import type { Pool } from "pg";

package/dist/tools/research/inspect-run.js

@@ -2,7 +2,7 @@
  * inspectRun — inspect workflow runs for the current analysis.
  *
  * Results are pull-only: workflows never append completion messages to a
- * conversation. List mode is active-first and paged. Targeted mode makes
+ * conversation. List mode puts the running runs first and is paged. Targeted mode makes
  * readiness explicit and can perform one bounded, abort-aware wait.
  */
 import { setTimeout as sleep } from "node:timers/promises";
@@ -20,7 +20,7 @@ const systemClock = {
     wait: (ms, signal) => sleep(ms, undefined, { signal }),
 };
 function isTerminal(status) {
-    return status === "completed" || status === "partial" || status === "failed" || status === "canceled";
+    return status === "completed" || status === "partial" || status === "failed" || status === "canceled" || status === "suspended_insufficient_funds";
 }
 function formatRun(r, verbose, exposePaths = isTerminal(r.status)) {
     return {
@@ -98,10 +98,10 @@ export function createInspectRunTool(pool, clock = systemClock) {
     return defineTool({
         id: "inspect_run",
         description: "Inspect workflow runs for this analysis. A run never posts its completion into the conversation; this tool is how you read it. " +
-            "Without a runId, returns an active-first paged list (running, suspended, then terminal history) with total and hasMore. " +
-            "With a runId, returns the run, its steps, and an inspectionState: not_found; in_progress; suspended (the run does not progress until it is resumed); " +
+            "Without a runId, returns a paged list (running runs first, then each other run) with total and hasMore. " +
+            "With a runId, returns the run, its steps, and an inspectionState: not_found; in_progress; suspended (the host suspended the run, it does not progress, and a new run of the plan can start); " +
             "or terminal (run.status completed, partial, failed, or canceled). " +
-            "Output paths appear only on a terminal run: run.synthesisPath when synthesisStatus is produced, and the summaryPath of each step that ran. " +
+            "Output paths appear only on a suspended or terminal run: run.synthesisPath when synthesisStatus is produced, and the summaryPath of each step that ran. " +
             "For a user-directed check, waitForTerminalSeconds can wait once for 1-30 seconds; if the cutoff returns in_progress, stop polling for that turn. " +
             "A wait on the run that the caller itself runs inside returns at once with selfWaitPrevented. " +
             "Default response is lightweight — pass includeDiagnostics:true to add error/duration/retry telemetry.",
@@ -179,8 +179,8 @@ export function createInspectRunTool(pool, clock = systemClock) {
             if (run.status === "suspended_insufficient_funds") {
                 return ok({
                     inspectionState: "suspended",
-                    message: "This run is suspended and will not progress until it is resumed.",
-                    run: formatRun(run, verbose, false),
+                    message: "The host suspended this run. The run does not progress. A new run of the plan can start.",
+                    run: formatRun(run, verbose, true),
                     steps,
                     ...wait,
                 });

package/dist/workflows/execute-analysis.d.ts

@@ -50,8 +50,9 @@
  *       the run before any step starts
  *     - a `suspend` error of a synthesis model request suspends the run in
  *       place of the synthesis failure
- *     - the analysis flips to `suspended_insufficient_funds` in
- *       `collectAndComplete`. The paused parent lands in `CANCELLED`, a
+ *     - the run row and the analysis flip to `suspended_insufficient_funds` in
+ *       `collectAndComplete`. The run status is terminal and does not block a
+ *       new run of the plan. The paused parent lands in `CANCELLED`, a
  *       durably reschedulable state; re-driving it is a future enhancement,
  *       not yet wired here. The reason of the host rides to the run row, the
  *       charge close, the metric, and the terminal part, unread.
@@ -160,7 +161,7 @@ export interface ExecuteAnalysisInput {
  * path returns — the caller joined an in-flight run, no new workflow was
  * started. Every other variant is a terminal status the parent reached.
  */
-export type ExecuteAnalysisFinalStatus = "running" | "completed" | "partial" | "failed" | "canceled";
+export type ExecuteAnalysisFinalStatus = "running" | "completed" | "partial" | "failed" | "canceled" | "suspended_insufficient_funds";
 export interface ExecuteAnalysisResult {
     readonly runId: string;
     readonly workflowId: string;

package/dist/workflows/execute-analysis.js

@@ -50,8 +50,9 @@
  *       the run before any step starts
  *     - a `suspend` error of a synthesis model request suspends the run in
  *       place of the synthesis failure
- *     - the analysis flips to `suspended_insufficient_funds` in
- *       `collectAndComplete`. The paused parent lands in `CANCELLED`, a
+ *     - the run row and the analysis flip to `suspended_insufficient_funds` in
+ *       `collectAndComplete`. The run status is terminal and does not block a
+ *       new run of the plan. The paused parent lands in `CANCELLED`, a
  *       durably reschedulable state; re-driving it is a future enhancement,
  *       not yet wired here. The reason of the host rides to the run row, the
  *       charge close, the metric, and the terminal part, unread.
@@ -79,12 +80,13 @@ import { ATTR_INFLEXA_STEP_ID, stableSpan } from "../lib/otel-spans.js";
 import { recordRunCompleted, recordStepCompleted, stepOutcomeOf } from "../lib/metrics.js";
 import { describeDbError } from "../lib/db-result.js";
 import { unwrapOrThrow } from "../lib/result.js";
-import { countArtifactsForRun, insertStepExecution, loadDataProfileStatus, queryActiveRun, queryStepArtifactPaths, queryStepsByRun, seedStepExecutions, setRunSynthesisOutcome, suspendAnalysis as suspendAnalysisQuery, sweepPendingStepExecutions, updateRunStatus, updateStepExecution, } from "../state/index.js";
+import { countArtifactsByRuns, insertStepExecution, loadDataProfileStatus, queryActiveRun, queryStepArtifactPaths, queryStepsByRun, seedStepExecutions, setRunSynthesisOutcome, suspendAnalysis as suspendAnalysisQuery, sweepPendingStepExecutions, updateRunStatus, updateStepExecution, } from "../state/index.js";
 import { addChatUsage, hasReportedUsage } from "../loop/metrics.js";
+import { flattenDataPart } from "../contracts/chat-frame.js";
 import { SYNTHESIS_AGENT_ID, loadStepSummariesFromDisk } from "../execution/run-synthesis.js";
 import { MAX_UPSTREAM_ARTIFACTS, composeStepBriefing, emptyStepMemory } from "../prompts/briefing.js";
 import { SYNTHESIS_STEP_ID, runDir, runStepDir, stepSubdir, stepWritePrefix, toSandboxPath } from "../workspace/paths.js";
-import { isChatDataPart } from "../sandbox/sandbox-step-translate.js";
+import { isChatDataPart, synthesisEmission } from "../sandbox/sandbox-step-translate.js";
 import { synthesizeRun } from "../app/synthesize-run.js";
 import { computeTopologicalLevels, scheduleReady, validatePlanDag } from "./execute-analysis-scheduler.js";
 import { recordCancelledChild } from "./metrics.js";
@@ -359,9 +361,20 @@ export function synthesisRowUpdate(outcome, durationMs) {
  */
 export function synthesizeFindings(args) {
     const { analysisId, runId, completedSteps, session, deps } = args;
+    const logger = (deps.logger ?? createNoopLogger()).named("executeAnalysis.synthesis");
+    // Observation is a diagnostic channel: a failed progress write is logged and never fails the synthesis.
+    let progressSeq = 0;
+    const writeProgressAlone = async (part, phase) => {
+        try {
+            await DBOS.writeStream("events", part);
+        }
+        catch (err) {
+            logger.warn("synthesis progress write failed (non-fatal)", { phase, ...logger.errorFields(err) });
+        }
+    };
     const emit = (event) => {
         const part = isChatDataPart(event)
-            ? event
+            ? flattenDataPart(event)
             : {
                 type: "data-loop-event",
                 data: { stepId: "synthesis", event },
@@ -395,14 +408,15 @@ export function synthesizeFindings(args) {
         // call path.
         session: forStep(session, SYNTHESIS_STEP_ID),
         emit,
-        onProgress: (phase, activity, extra = {}) => DBOS.writeStream("events", {
-            type: "data-synthesis-progress",
-            id: `synthesis-progress-${runId}`,
-            runId,
-            phase,
-            activity,
-            ...extra,
-        }),
+        onProgress: async (phase, activity, extra = {}) => {
+            // Synthesis runs inside one `DBOS.runStep`, thus `DBOS.now()` reads the wall clock here, and a rerun of
+            // the step after a crash writes its entries again under the same ids. A reader dedups an entry by id.
+            const seq = progressSeq++;
+            const at = new Date(await DBOS.now()).toISOString();
+            const parts = synthesisEmission(runId, SYNTHESIS_STEP_ID, seq, phase, activity, at, extra);
+            await writeProgressAlone(parts.progress, phase);
+            await writeProgressAlone(parts.entry, phase);
+        },
     });
 }
 // ── Workflow registration ────────────────────────────────────────────
@@ -1086,7 +1100,7 @@ async function collectAndComplete(args) {
         durationMs: terminalAtMs - startedAtMs,
     }, input.runSession);
     await ledgerStep(logger.with({ status }), "persist-final-status", async () => {
-        const written = await updateRunStatus(deps.pool, runId, status, failureReason ?? (status === "canceled" && suspended === null ? "external_cancel" : null));
+        const written = await updateRunStatus(deps.pool, runId, status, failureReason ?? (status === "canceled" ? "external_cancel" : null));
         if (written.isErr())
             return written;
         // The outcome metrics ride inside the step that persists the terminal status: DBOS
@@ -1119,10 +1133,9 @@ async function collectAndComplete(args) {
         await ledgerStep(logger.with({ synthesisStatus: outcome.status }), "persist-synthesis-outcome", () => setRunSynthesisOutcome(deps.pool, runId, outcome.status, outcome.reason));
     }
     // Sweep never-started steps to `skipped` — but ONLY on genuinely-terminal
-    // paths. The gate is the BRANCH, not the written run status: the resumable
-    // suspension below also writes "canceled", yet its pending rows must survive
-    // for the resumed workflow to execute. Log-don't-rollback, like every other
-    // finalisation step here.
+    // paths. The gate is the BRANCH, not the written run status: the pending rows
+    // of a suspended run must survive for a later resume. Log-don't-rollback, like
+    // every other finalisation step here.
     if (suspended === null) {
         await ledgerStep(logger, "sweep-pending-steps", () => sweepPendingStepExecutions(deps.pool, runId));
     }
@@ -1149,9 +1162,9 @@ async function collectAndComplete(args) {
     // beat the CLI's poll-and-shutdown). These branches only fan out the UI stream part, whose
     // completed/failed shapes genuinely differ — the provenance record does not.
     if (status === "completed" || status === "partial") {
-        const artifactCount = await DBOS.runStep(async () => await countArtifactsForRun(deps.pool, input.analysisId, runId).unwrapOr(0), {
-            name: "count-run-artifacts",
-        });
+        const artifactCount = await DBOS.runStep(async () => await countArtifactsByRuns(deps.pool, input.analysisId, [runId])
+            .map((counts) => counts[0]?.count ?? 0)
+            .unwrapOr(0), { name: "count-run-artifacts" });
         await emitStreamPart({
             type: "data-run-completed",
             runId,
@@ -1197,7 +1210,7 @@ async function collectAndComplete(args) {
 function deriveFinalStatus(args) {
     const { totalSteps, completed, failed, canceled, suspended } = args;
     if (suspended)
-        return "canceled";
+        return "suspended_insufficient_funds";
     if (failed.size > 0) {
         return completed.size > 0 ? "partial" : "failed";
     }