@inflexa-ai/harness 0.43.1 → 0.45.0

package/dist/report-model/pin-snapshot.js

@@ -17,54 +17,11 @@
  * keeps the membership role, thus the record map is optional and it changes no resolution.
  */
 import { err, ok } from "neverthrow";
-import { open } from "node:fs/promises";
-import { join } from "node:path";
-import { tryFs } from "../lib/fs-result.js";
+import { readSynthesisText } from "../execution/run-synthesis.js";
 import { queryAnalysisArtifacts } from "../state/artifacts.js";
 import { queryRunsByAnalysis } from "../state/runs.js";
-import { isSafeId, runDir } from "../workspace/paths.js";
-/** The file name of the synthesis record inside the run directory. */
-const SYNTHESIS_FILE = "synthesis.json";
-/**
- * The cap of one synthesis read. A synthesis record is small by construction, and the cap bounds the
- * cost of a file that is not. A file over the cap gives no key, because a cut JSON text cannot parse.
- */
-const SYNTHESIS_CAP_BYTES = 1024 * 1024;
 /** The page size of the run listing. The listing walks the pages until a short page ends the walk. */
 const RUN_PAGE_SIZE = 200;
-/**
- * Read a synthesis record under the cap, or give `undefined` when the bytes do not come back.
- *
- * The read takes a bounded byte window, thus a file of any size costs the cap. An absent file, a genuine
- * read fault, and a file over the cap each give `undefined`, because the collection reports no error for
- * one record.
- */
-async function readSynthesisText(absolute) {
-    return tryFs("pinReportSnapshot.readSynthesis", async () => {
-        const handle = await open(absolute, "r");
-        try {
-            // The window takes one byte more than the cap. A read that fills it states that the file
-            // holds more bytes than the cap admits, thus the two conditions stay apart.
-            const buffer = Buffer.alloc(SYNTHESIS_CAP_BYTES + 1);
-            // One read of a network-backed file can give fewer bytes than the window holds. Such a
-            // short read cuts the text in the middle of the JSON, and the record then parses to no
-            // key at all. Thus the loop reads again from the offset that the last read reached, and
-            // it stops when the window fills or when a read gives no byte.
-            let filled = 0;
-            while (filled < buffer.length) {
-                const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
-                if (bytesRead === 0) {
-                    break;
-                }
-                filled += bytesRead;
-            }
-            return filled > SYNTHESIS_CAP_BYTES ? undefined : buffer.subarray(0, filled).toString("utf8");
-        }
-        finally {
-            await handle.close();
-        }
-    }, { path: absolute, onAbsent: () => undefined }).unwrapOr(undefined);
-}
 /** The trimmed text of a field, or `undefined` when the field is not a non-empty string. */
 function trimmedText(value) {
     if (typeof value !== "string") {
@@ -166,10 +123,10 @@ function citationsOf(text) {
 async function collectCitations(pool, resolveWorkspaceRoot, analysisId) {
     let root;
     try {
-        root = resolveWorkspaceRoot(analysisId);
+        root = await resolveWorkspaceRoot(analysisId);
     }
     catch {
-        // The seam signals an unresolvable resource by a throw. The artifact map still states the
+        // The seam signals an unresolvable resource by a rejection. The artifact map still states the
         // membership of the session, thus the fault costs the citation list alone.
         return ok({ keys: [], records: new Map() });
     }
@@ -181,12 +138,7 @@ async function collectCitations(pool, resolveWorkspaceRoot, analysisId) {
             return err({ kind: "run-listing-failed", cause: page.error.cause });
         }
         for (const run of page.value) {
-            // The path builder refuses an id that can escape the run tree. A refusal is a throw, thus
-            // the guard keeps the collection on the value channel.
-            if (!isSafeId(run.runId)) {
-                continue;
-            }
-            const text = await readSynthesisText(join(root, runDir(run.runId), SYNTHESIS_FILE));
+            const text = await readSynthesisText({ workspaceRoot: root, runId: run.runId });
             if (text === undefined) {
                 continue;
             }

package/dist/runtime/assemble.d.ts

@@ -14,8 +14,9 @@
  * `applicationVersion` stamp because all registration happens in this one call,
  * before launch — a blue/green drain treats them as a single cohort.
  */
-import { type Result } from "neverthrow";
+import { type Result, type ResultAsync } from "neverthrow";
 import { type ConversationAgentDeps } from "../agents/conversation-agent.js";
+import { type ApprovePlanInput, type ApprovePlanRefusal, type PlanApproval } from "../app/approve-plan.js";
 import { type ReportSessionRuntime } from "../app/report-session-runtime.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { ResourcePolicy } from "../config/resource-limits.js";
@@ -97,7 +98,7 @@ export interface ReportResolverScope {
  * The factory that gives the reference resolver of one report tool call. The harness wires the production
  * realization, and an embedder can bind its own at its composition root.
  */
-export type MakeReportReferenceResolver = (scope: ReportResolverScope) => ReferenceResolver;
+export type MakeReportReferenceResolver = (scope: ReportResolverScope) => Promise<ReferenceResolver>;
 export interface CoreRuntimeDeps {
     readonly conversation: ConversationAssemblyDeps;
     readonly workflows: CoreWorkflowDeps;
@@ -235,6 +236,12 @@ export interface CoreRuntime {
     readonly reportSession: Pick<ReportSessionRuntime, "ensureSessionState">;
     readonly workflows: RegisteredWorkflows;
     readonly citationResolver: CitationResolver;
+    /**
+     * Approve a stored plan by its id and start its run with no model call. It runs over the deps that
+     * reach the `execute_analysis` tool of the conversation agent, thus the approval and the tool launch
+     * a plan the same way.
+     */
+    readonly approvePlan: (input: ApprovePlanInput) => ResultAsync<PlanApproval, ApprovePlanRefusal>;
 }
 /**
  * The eyes of the composition, or none.

package/dist/runtime/assemble.js

@@ -17,6 +17,7 @@
 import { err, ok } from "neverthrow";
 import { createConversationAgent } from "../agents/conversation-agent.js";
 import { createReportSessionAgent } from "../agents/report-session-agent.js";
+import { approvePlan } from "../app/approve-plan.js";
 import { createReportSessionRuntime } from "../app/report-session-runtime.js";
 import { createNoopUsageRecorder } from "../billing/noop-usage-recorder.js";
 import { hasBrowserUrl } from "../lib/chrome.js";
@@ -152,10 +153,10 @@ export function assembleCoreRuntime(deps) {
     // for each tool call. The extraction arm falls through to the registered extract-values
     // callable for an over-cap file or a host parse fault. The cap gates the host read, and
     // the resolver defaults it to 16 MiB.
-    const makeProductionReportResolver = (scope) => {
+    const makeProductionReportResolver = async (scope) => {
         const arm = createExtractionArm(bindExtractionTrigger({ runAuthorizer: conversation.runAuthorizer, workflow: extractValues }, { auth: scope.auth, analysisId: scope.analysisId }));
         return createProductionResolver({
-            workspaceRoot: conversation.resolveWorkspaceRoot(scope.analysisId),
+            workspaceRoot: await conversation.resolveWorkspaceRoot(scope.analysisId),
             analysisId: scope.analysisId,
             extractionArm: arm,
             readCache: reportArtifactReads.forAnalysis(scope.analysisId),
@@ -210,5 +211,15 @@ export function assembleCoreRuntime(deps) {
             deriveTableExec,
         },
         citationResolver,
+        approvePlan: (input) => approvePlan({
+            pool: conversation.pool,
+            executeAnalysisWorkflow: executeAnalysis,
+            runAuthorizer: conversation.runAuthorizer,
+            runLauncher: conversation.runLauncher,
+            ...(resourcePolicy ? { resourcePolicy } : {}),
+            ...(conversation.extendAnalysisFarm ? { extendAnalysisFarm: conversation.extendAnalysisFarm } : {}),
+            ...(conversation.logger ? { logger: conversation.logger } : {}),
+            ...(deps.provenance ? { provenance: deps.provenance } : {}),
+        }, input),
     };
 }

package/dist/runtime/boot.d.ts

@@ -25,6 +25,9 @@
  *      legacy-workflow reap, an agent-switch install). Runs after registration
  *      so it may close over the registered callables.
  *   7. `launchDbos(...)` — the last registration-dependent step.
+ *   8. `reconcileOrphanedRuns(pool)` — fails each `running` run whose workflow never started. It runs
+ *      after launch, thus a workflow that recovery re-queued counts as started. A failure is logged and does
+ *      not stop the boot, because the repair only frees the slot of a plan.
  *
  * No step reads or rewrites stored conversation display. A boot that validated
  * every `messages` row is what let a single retired part key fail startup for a

package/dist/runtime/boot.js

@@ -25,6 +25,9 @@
  *      legacy-workflow reap, an agent-switch install). Runs after registration
  *      so it may close over the registered callables.
  *   7. `launchDbos(...)` — the last registration-dependent step.
+ *   8. `reconcileOrphanedRuns(pool)` — fails each `running` run whose workflow never started. It runs
+ *      after launch, thus a workflow that recovery re-queued counts as started. A failure is logged and does
+ *      not stop the boot, because the repair only frees the slot of a plan.
  *
  * No step reads or rewrites stored conversation display. A boot that validated
  * every `messages` row is what let a single retired part key fail startup for a
@@ -38,6 +41,7 @@
 import { SANDBOX_AGENT_META } from "../agents/sandbox/index.js";
 import { validateAgentSkills } from "../agents/sandbox/validate-skills.js";
 import { initCortexState } from "../state/init.js";
+import { reconcileOrphanedRuns } from "../state/runs.js";
 import { assembleCoreRuntime } from "./assemble.js";
 import { assertConnectionBudget } from "./connection-budget.js";
 import { launchDbos, shutdownDbos } from "./dbos.js";
@@ -56,7 +60,12 @@ export async function bootHarness(deps) {
     const runtime = assembleCoreRuntime(core);
     await deps.beforeLaunch?.();
     await launchDbos({ config: deps.dbos, logger });
-    logger.named("boot").info("harness booted", { executorId: deps.dbos.executorId });
+    const bootLog = logger.named("boot");
+    (await reconcileOrphanedRuns(pool)).match((runIds) => {
+        if (runIds.length > 0)
+            bootLog.warn("failed the runs whose workflow never started", { runIds });
+    }, (error) => bootLog.warn("the repair of the orphaned runs failed", bootLog.errorFields(error)));
+    bootLog.info("harness booted", { executorId: deps.dbos.executorId });
     const shutdown = (signal) => runShutdownSequence({
         signal,
         logger,

package/dist/sandbox/client.d.ts

@@ -43,7 +43,7 @@ export interface SandboxClient {
      * Each spawn failure is an `err` value, the refusal of the label hook
      * (`labels_refused`) included: a spawn path splits the result with
      * `keepSuspendingRefusal`. Only a defect of the deployment config, or a
-     * throw of the workspace-root resolver, throws, and it fails the workflow.
+     * rejection of the workspace-root resolver, throws, and it fails the workflow.
      */
     createSandbox(session: SpawnSession, spec: SandboxSpec, identity: SandboxIdentity): ResultAsync<SandboxRef, SandboxError>;
     /**

package/dist/sandbox/create-sandbox.js

@@ -57,7 +57,7 @@ export async function precreateStepTree(deps, coords) {
     // `tailWritePrefix` (not a raw `join`) so every segment runs through the same
     // id validation the mount builders apply — a crafted tail cannot escape the
     // resolved root.
-    const writeDir = tailWritePrefix({ workspaceRoot: deps.resolveWorkspaceRoot(coords.analysisId), tail: write.tail });
+    const writeDir = tailWritePrefix({ workspaceRoot: await deps.resolveWorkspaceRoot(coords.analysisId), tail: write.tail });
     await mkdir(writeDir, { recursive: true });
     await Promise.all(write.subdirs.map((sub) => mkdir(join(writeDir, sub), { recursive: true })));
     if (deps.stepTreeAccess === "world-writable") {

package/dist/sandbox/docker-client.js

@@ -287,7 +287,7 @@ export function createDockerSandboxOps(config) {
                     toolchainSource: config.toolchainSource,
                     cache: cacheBindable,
                 });
-                const hostTreePath = config.resolveWorkspaceRoot(analysisId);
+                const hostTreePath = await config.resolveWorkspaceRoot(analysisId);
                 // `tailWritePrefix` (not a raw `join`) so the RW bind source runs through
                 // the same validation as the pre-created write tree — a crafted stepId or
                 // a crafted tail cannot escape the resolved root into the container. The

package/dist/sandbox/k8s-client.js

@@ -88,11 +88,11 @@ function buildKubeApi() {
  * mount a directory the harness never wrote to — fail loudly instead. `createSandbox` runs
  * inside a DBOS workflow body, where a throw is the durable failure signal.
  */
-function workspaceSubPathFor(config, analysisId) {
+async function workspaceSubPathFor(config, analysisId) {
     if (!config.sessionPvcRoot) {
         throw new Error("k8s sandbox: sessionPvc is set but sessionPvcRoot is not — the PVC subPath of a workspace root cannot be derived");
     }
-    const rel = relativePath(config.sessionPvcRoot, config.resolveWorkspaceRoot(analysisId));
+    const rel = relativePath(config.sessionPvcRoot, await config.resolveWorkspaceRoot(analysisId));
     const posix = rel.split(sep).join("/");
     if (posix.length === 0 || posix.startsWith("..")) {
         throw new Error(`k8s sandbox: workspace root for ${analysisId} does not live under sessionPvcRoot (${config.sessionPvcRoot})`);
@@ -111,7 +111,7 @@ function pvcSubPath(value, what) {
     }
     return value;
 }
-function buildJobSpec(session, sandboxSpec, hostLabels, config, identity, farm, libsMounted) {
+async function buildJobSpec(session, sandboxSpec, hostLabels, config, identity, farm, libsMounted) {
     const { sandboxId } = identity;
     // The lock gate of the package-store spec: `farmPath` is PVC-relative,
     // thus this host can prove the lock only through `libStorePvcRoot`. The
@@ -148,7 +148,7 @@ function buildJobSpec(session, sandboxSpec, hostLabels, config, identity, farm,
     const volumes = [];
     const volumeMounts = [];
     if (config.sessionPvc) {
-        const subPaths = buildSessionSubPaths(coords, workspaceSubPathFor(config, session.scope.analysisId));
+        const subPaths = buildSessionSubPaths(coords, await workspaceSubPathFor(config, session.scope.analysisId));
         volumes.push({
             name: SESSION_VOLUME_NAME,
             persistentVolumeClaim: { claimName: config.sessionPvc },
@@ -491,7 +491,7 @@ export function createK8sSandboxOps(config) {
                             .warn("the farm of the analysis has no usable inflexa.lock at sandbox creation — mounting no package store (sandbox degrades to available:false)", { libStorePvc: config.libStorePvc, farmPath: farm.farmPath, lockError: lock.error.type, sandboxId });
                     }
                 }
-                const job = buildJobSpec(session, spec, hostLabels, config, identity, farm, libsMounted);
+                const job = await buildJobSpec(session, spec, hostLabels, config, identity, farm, libsMounted);
                 const adopted = await createOrAdoptJob(batchApi, coreApi, config.namespace, sandboxId, spec.childWorkflowId, job);
                 if (adopted.isErr())
                     return err(adopted.error);

package/dist/sandbox/sandbox-step-translate.d.ts

@@ -5,6 +5,7 @@
  * extraction/fold, and the chat-data-part narrowing a workflow body composes
  * into its emitters.
  */
+import type { ActivityEntryPart, StepActivityPart, StepPhase, SynthesisPhase, SynthesisProgressPart } from "../contracts/chat-parts.js";
 import type { ChatDataPart, EmitFn } from "../loop/types.js";
 import type { ToolDetailResolver } from "../tools/detail-resolver.js";
 /**
@@ -19,6 +20,28 @@ import type { ToolDetailResolver } from "../tools/detail-resolver.js";
  * producers construct it identically.
  */
 export declare function stepPartId(kind: string, runId: string, stepId: string): string;
+/**
+ * The two parts of one activity emission: the reconciling `data-step-activity` that holds the current activity,
+ * and the `data-activity-entry` that keeps the emission in the run stream. Both carry the same phase, activity,
+ * and time. `seq` is the position of the emission in the body of its workflow, so each entry has its own id, and a
+ * recovered body counts the same emissions again and gives the same ids. Every producer mints the two parts here.
+ */
+export declare function activityEmission(frame: {
+    readonly runId: string;
+    readonly stepId: string;
+}, seq: number, phase: StepPhase, activity: string, at: string): {
+    readonly activity: StepActivityPart;
+    readonly entry: ActivityEntryPart;
+};
+/**
+ * The two parts of one synthesis progress report: the reconciling `data-synthesis-progress` that holds the current
+ * phase, and the `data-activity-entry` that keeps the report in the run stream under the synthesis step. `seq` is the
+ * position of the report in the synthesis, so each entry has its own id. The `extra` fields stay on the progress part.
+ */
+export declare function synthesisEmission(runId: string, stepId: string, seq: number, phase: SynthesisPhase, activity: string, at: string, extra: Pick<SynthesisProgressPart, "delegationCount" | "reason" | "error">): {
+    readonly progress: SynthesisProgressPart;
+    readonly entry: ActivityEntryPart;
+};
 /**
  * The live-activity phrase for one tool call: the tool's name, then its own
  * description of this call when it has one.

package/dist/sandbox/sandbox-step-translate.js

@@ -19,6 +19,30 @@
 export function stepPartId(kind, runId, stepId) {
     return `${kind}-${runId}-${stepId}`;
 }
+/**
+ * The two parts of one activity emission: the reconciling `data-step-activity` that holds the current activity,
+ * and the `data-activity-entry` that keeps the emission in the run stream. Both carry the same phase, activity,
+ * and time. `seq` is the position of the emission in the body of its workflow, so each entry has its own id, and a
+ * recovered body counts the same emissions again and gives the same ids. Every producer mints the two parts here.
+ */
+export function activityEmission(frame, seq, phase, activity, at) {
+    const { runId, stepId } = frame;
+    return {
+        activity: { type: "data-step-activity", id: stepPartId("step-activity", runId, stepId), runId, stepId, phase, activity, at },
+        entry: { type: "data-activity-entry", id: `${stepPartId("activity-entry", runId, stepId)}-${seq}`, runId, stepId, phase, activity, at },
+    };
+}
+/**
+ * The two parts of one synthesis progress report: the reconciling `data-synthesis-progress` that holds the current
+ * phase, and the `data-activity-entry` that keeps the report in the run stream under the synthesis step. `seq` is the
+ * position of the report in the synthesis, so each entry has its own id. The `extra` fields stay on the progress part.
+ */
+export function synthesisEmission(runId, stepId, seq, phase, activity, at, extra) {
+    return {
+        progress: { type: "data-synthesis-progress", id: `synthesis-progress-${runId}`, runId, phase, activity, at, ...extra },
+        entry: { type: "data-activity-entry", id: `${stepPartId("activity-entry", runId, stepId)}-${seq}`, runId, stepId, phase, activity, at },
+    };
+}
 /**
  * The live-activity phrase for one tool call: the tool's name, then its own
  * description of this call when it has one.

package/dist/schemas/artifact-manifest.d.ts

@@ -30,5 +30,5 @@ export declare const ArtifactManifestEntrySchema: z.ZodObject<{
     hash: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ArtifactManifestEntry = z.infer<typeof ArtifactManifestEntrySchema>;
-/** Infer artifact type from a file path based on its parent subdirectory. */
+/** Infer artifact type from a file path. A folder segment at the start of the path or after a `/` gives its type. */
 export declare function inferArtifactType(filePath: string): ArtifactType;

package/dist/schemas/artifact-manifest.js

@@ -22,15 +22,17 @@ export const ArtifactManifestEntrySchema = z.object({
     /** SHA-256 content hash for integrity verification (e.g., sha256:abcdef...). */
     hash: z.string().optional(),
 });
-/** Infer artifact type from a file path based on its parent subdirectory. */
+const FOLDER_TYPES = [
+    ["figures", "figure"],
+    ["scripts", "script"],
+    ["logs", "log"],
+    ["notebooks", "notebook"],
+];
+/** Infer artifact type from a file path. A folder segment at the start of the path or after a `/` gives its type. */
 export function inferArtifactType(filePath) {
-    if (filePath.includes("/figures/"))
-        return "figure";
-    if (filePath.includes("/scripts/"))
-        return "script";
-    if (filePath.includes("/logs/"))
-        return "log";
-    if (filePath.includes("/notebooks/"))
-        return "notebook";
+    for (const [folder, type] of FOLDER_TYPES) {
+        if (filePath.startsWith(`${folder}/`) || filePath.includes(`/${folder}/`))
+            return type;
+    }
     return "output";
 }

package/dist/schemas/plan-schemas.d.ts

@@ -11,13 +11,8 @@ export declare const PlanStepSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
-    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    track: z.ZodString;
-    step_type: z.ZodString;
-    question: z.ZodString;
-    acceptance_criteria: z.ZodArray<z.ZodString>;
     caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    question: z.ZodString;
     depends_on: z.ZodArray<z.ZodString>;
     resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
         cpu: z.ZodNumber;
@@ -26,6 +21,11 @@ export declare const PlanStepSchema: z.ZodObject<{
             count: z.ZodNumber;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    track: z.ZodString;
+    step_type: z.ZodString;
+    acceptance_criteria: z.ZodArray<z.ZodString>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     agent: z.ZodEnum<{
         [x: string]: string;
     }>;
@@ -44,13 +44,8 @@ export declare const PlannerPlanSchema: z.ZodObject<{
         context: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         id: z.ZodString;
-        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        track: z.ZodString;
-        step_type: z.ZodString;
-        question: z.ZodString;
-        acceptance_criteria: z.ZodArray<z.ZodString>;
         caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        question: z.ZodString;
         depends_on: z.ZodArray<z.ZodString>;
         resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
             cpu: z.ZodNumber;
@@ -59,6 +54,11 @@ export declare const PlannerPlanSchema: z.ZodObject<{
                 count: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
+        track: z.ZodString;
+        step_type: z.ZodString;
+        acceptance_criteria: z.ZodArray<z.ZodString>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         agent: z.ZodEnum<{
             [x: string]: string;
         }>;
@@ -86,13 +86,8 @@ export declare const PlanningAgentOutputSchema: z.ZodObject<{
             context: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
-            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            track: z.ZodString;
-            step_type: z.ZodString;
-            question: z.ZodString;
-            acceptance_criteria: z.ZodArray<z.ZodString>;
             caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            question: z.ZodString;
             depends_on: z.ZodArray<z.ZodString>;
             resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
                 cpu: z.ZodNumber;
@@ -101,6 +96,11 @@ export declare const PlanningAgentOutputSchema: z.ZodObject<{
                     count: z.ZodNumber;
                 }, z.core.$strip>>;
             }, z.core.$strip>>>;
+            track: z.ZodString;
+            step_type: z.ZodString;
+            acceptance_criteria: z.ZodArray<z.ZodString>;
+            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             agent: z.ZodEnum<{
                 [x: string]: string;
             }>;

package/dist/schemas/run-synthesis.d.ts

@@ -31,11 +31,11 @@ export declare const SynthesizedFindingSchema: z.ZodObject<{
         high: "high";
     }>;
     noveltyStatus: z.ZodEnum<{
-        expected: "expected";
         novel: "novel";
         confirmed: "confirmed";
         partially_confirmed: "partially_confirmed";
         contradicted: "contradicted";
+        expected: "expected";
     }>;
     literatureInterpretation: z.ZodString;
     references: z.ZodArray<z.ZodObject<{
@@ -97,11 +97,11 @@ export declare const RunSynthesisSchema: z.ZodObject<{
             high: "high";
         }>;
         noveltyStatus: z.ZodEnum<{
-            expected: "expected";
             novel: "novel";
             confirmed: "confirmed";
             partially_confirmed: "partially_confirmed";
             contradicted: "contradicted";
+            expected: "expected";
         }>;
         literatureInterpretation: z.ZodString;
         references: z.ZodArray<z.ZodObject<{

package/dist/state/analyses-metrics.d.ts

@@ -1,11 +1,44 @@
 /**
- * Cross-entity aggregate reads used by `routes/analyses-metrics.ts` to build
- * the per-analysis metrics view. Each query touches one table; the view is
- * the batch shape callers want.
+ * Cross-entity aggregate reads for a list of analyses. Each read takes the ids
+ * of a page and sends one statement, whatever the length of the list: an
+ * embedder builds the per-analysis summary of a list from these reads, never
+ * from one read for each analysis.
  */
 import { type ResultAsync } from "neverthrow";
+import type { DataProfileLifecycleStatus } from "../contracts/data-profile.js";
 import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
+import type { RunStatus, TerminalRunStatus } from "./schema.js";
+/** The newest run of one analysis, with the title of its plan and the counts of its step rows. */
+export interface LatestRunSummary {
+    readonly analysisId: string;
+    readonly runId: string;
+    readonly status: RunStatus;
+    readonly planTitle: string | null;
+    readonly doneSteps: number;
+    readonly totalSteps: number;
+    readonly startedAt: string;
+    readonly completedAt: string | null;
+}
+/** A run of a list of run ids, with the fields of the newest-run read and the thread of the run. */
+export interface RunProgressSummary extends LatestRunSummary {
+    /** The thread of the run as the ledger stores it, or `null`. */
+    readonly threadId: string | null;
+}
+/** A terminal run that ended at or after a time. */
+export interface EndedRunSummary {
+    readonly analysisId: string;
+    readonly runId: string;
+    readonly status: TerminalRunStatus;
+    readonly completedAt: string;
+}
+/** The data profile state of one analysis that has a profile status. */
+export interface DataProfileSummary {
+    readonly analysisId: string;
+    readonly status: DataProfileLifecycleStatus;
+    readonly completedAt: string | null;
+    readonly profiledFiles: number | null;
+}
 export declare function queryRunCountsByAnalyses(pool: Querier, analysisIds: string[]): ResultAsync<Array<{
     analysisId: string;
     status: string;
@@ -15,7 +48,46 @@ export declare function queryThreadCountsByAnalyses(pool: Querier, analysisIds:
     analysisId: string;
     count: number;
 }>, DbError>;
-export declare function queryDataProfileStatusByAnalyses(pool: Querier, analysisIds: string[]): ResultAsync<Array<{
-    analysisId: string;
-    status: string | null;
-}>, DbError>;
+/**
+ * The newest run of each analysis of a list, in one statement. An analysis with
+ * no run has no entry. The newest run has the latest `started_at`, and `run_id`
+ * breaks a tie in descending order. The `LATERAL` subquery reads
+ * `idx_cortex_runs_analysis_started`, thus one index entry for each analysis
+ * and not a sort of the run history.
+ *
+ * The plan joins on `plan_id` and `analysis_id`: a plan of a different analysis
+ * gives no title, the scope rule of `loadPlan`. The statement gives the title
+ * only when it is a string, and the row mapping trims it with `trim()`, the
+ * rule of the cli `planTitleOf`. A blank title or a title that is not a string
+ * reads as `null`. The step counts
+ * cover the ledger rows of the selected run only, the reserved synthesis row
+ * included.
+ */
+export declare function queryLatestRunsByAnalyses(pool: Querier, analysisIds: string[]): ResultAsync<LatestRunSummary[], DbError>;
+/**
+ * The progress of each run of a list of run ids, in one statement. An id with
+ * no run row has no entry. The entries come newest first by `started_at`, and
+ * `run_id` breaks a tie in descending order. The plan title and the step counts
+ * follow the rules of `queryLatestRunsByAnalyses`, and each entry adds the
+ * thread of the run.
+ */
+export declare function queryRunProgressByRuns(pool: Querier, runIds: string[]): ResultAsync<RunProgressSummary[], DbError>;
+/**
+ * The newest `limit` terminal runs of every analysis that ended at or after
+ * `since`, newest completion first, with `run_id` breaking a tie in descending
+ * order. `since` is in the form of `toISOString()`, the form of each
+ * `completed_at` stamp, thus the text comparison is the time comparison. The
+ * statement walks `idx_cortex_runs_completed`.
+ */
+export declare function queryRunsEndedSince(pool: Querier, input: {
+    since: string;
+    limit: number;
+}): ResultAsync<EndedRunSummary[], DbError>;
+/**
+ * The profile state of each analysis of a list, in one statement. An analysis
+ * with no ledger row, or with a cleared row whose status is null, has no entry:
+ * the same collapsed absence as `loadDataProfileStatus`. The statement selects
+ * only the three parts of the stored result that the file count reads, and the
+ * count itself is `profileDatasetFileCount`.
+ */
+export declare function queryDataProfileStatusByAnalyses(pool: Querier, analysisIds: string[]): ResultAsync<DataProfileSummary[], DbError>;