@inflexa-ai/harness 0.45.0 → 0.46.0

package/dist/schemas/workflow-state.d.ts

@@ -5,6 +5,47 @@
  * and the completion schemas that validate LLM structured output.
  */
 import { z } from "zod";
+/**
+ * One scientific setting of a grounded step: a parameter of the procedure
+ * that `knowledge_recommend` returned, with the procedure step it belongs to
+ * and the source of its value. The host binds the settings to the template
+ * of the step at dispatch, thus a template default never replaces a plan
+ * decision silently.
+ */
+export declare const GroundingSettingSchema: z.ZodObject<{
+    step: z.ZodString;
+    name: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GroundingSetting = z.infer<typeof GroundingSettingSchema>;
+/**
+ * The grounding of one method step: the claim identifiers and the snapshot
+ * digest that `knowledge_recommend` returned in this run, the template the
+ * step renders, the settings of the procedure, and a one-line reason.
+ * Optional on both step schemas, thus a stored plan and a plan made without
+ * the knowledge service load and validate as before. Phase 0 validates the
+ * shape only. An empty field is visible: the evaluation counts a method step
+ * without a value as ungrounded.
+ */
+export declare const GroundingSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        flagged: "flagged";
+        grounded: "grounded";
+        ungrounded: "ungrounded";
+    }>;
+    snapshot: z.ZodString;
+    claims: z.ZodArray<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        step: z.ZodString;
+        name: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type Grounding = z.infer<typeof GroundingSchema>;
 /**
  * A step of an analysis plan. `PlanStepSchema` (schemas/plan-schemas.ts) narrows
  * this into the planner's output contract and emits it as the `submit_plan`
@@ -24,10 +65,10 @@ export declare const AnalysisStepSchema: z.ZodObject<{
     packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
     depends_on: z.ZodArray<z.ZodString>;
     status: z.ZodDefault<z.ZodEnum<{
+        completed: "completed";
         failed: "failed";
         pending: "pending";
         running: "running";
-        completed: "completed";
         skipped: "skipped";
     }>>;
     resources: z.ZodOptional<z.ZodObject<{
@@ -37,7 +78,25 @@ export declare const AnalysisStepSchema: z.ZodObject<{
             count: z.ZodNumber;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    grounding: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            flagged: "flagged";
+            grounded: "grounded";
+            ungrounded: "ungrounded";
+        }>;
+        snapshot: z.ZodString;
+        claims: z.ZodArray<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            name: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
     agent: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodNumber>;
     maxSteps: z.ZodNumber;
     description: z.ZodOptional<z.ZodString>;
@@ -61,10 +120,10 @@ export declare const AnalysisPlanSchema: z.ZodObject<{
         packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
         depends_on: z.ZodArray<z.ZodString>;
         status: z.ZodDefault<z.ZodEnum<{
+            completed: "completed";
             failed: "failed";
             pending: "pending";
             running: "running";
-            completed: "completed";
             skipped: "skipped";
         }>>;
         resources: z.ZodOptional<z.ZodObject<{
@@ -74,7 +133,25 @@ export declare const AnalysisPlanSchema: z.ZodObject<{
                 count: z.ZodNumber;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        grounding: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                flagged: "flagged";
+                grounded: "grounded";
+                ungrounded: "ungrounded";
+            }>;
+            snapshot: z.ZodString;
+            claims: z.ZodArray<z.ZodString>;
+            template: z.ZodOptional<z.ZodString>;
+            settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                step: z.ZodString;
+                name: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                source: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
         agent: z.ZodOptional<z.ZodString>;
+        capability: z.ZodOptional<z.ZodString>;
         timeout: z.ZodOptional<z.ZodNumber>;
         maxSteps: z.ZodNumber;
         description: z.ZodOptional<z.ZodString>;
@@ -133,10 +210,10 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
             depends_on: z.ZodArray<z.ZodString>;
             status: z.ZodDefault<z.ZodEnum<{
+                completed: "completed";
                 failed: "failed";
                 pending: "pending";
                 running: "running";
-                completed: "completed";
                 skipped: "skipped";
             }>>;
             resources: z.ZodOptional<z.ZodObject<{
@@ -146,7 +223,25 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     count: z.ZodNumber;
                 }, z.core.$strip>>;
             }, z.core.$strip>>;
+            grounding: z.ZodOptional<z.ZodObject<{
+                status: z.ZodEnum<{
+                    flagged: "flagged";
+                    grounded: "grounded";
+                    ungrounded: "ungrounded";
+                }>;
+                snapshot: z.ZodString;
+                claims: z.ZodArray<z.ZodString>;
+                template: z.ZodOptional<z.ZodString>;
+                settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    step: z.ZodString;
+                    name: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                    source: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                reason: z.ZodString;
+            }, z.core.$strip>>;
             agent: z.ZodOptional<z.ZodString>;
+            capability: z.ZodOptional<z.ZodString>;
             timeout: z.ZodOptional<z.ZodNumber>;
             maxSteps: z.ZodNumber;
             description: z.ZodOptional<z.ZodString>;
@@ -160,7 +255,7 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"json">;
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
     label: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"text">;
@@ -176,16 +271,16 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
  */
 export declare const SuspensionActionSchema: z.ZodObject<{
     label: z.ZodString;
-    value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
     variant: z.ZodOptional<z.ZodEnum<{
         default: "default";
-        outline: "outline";
         destructive: "destructive";
+        outline: "outline";
     }>>;
     icon: z.ZodOptional<z.ZodEnum<{
+        "alert-circle": "alert-circle";
         check: "check";
         x: "x";
-        "alert-circle": "alert-circle";
     }>>;
 }, z.core.$strip>;
 /**
@@ -202,9 +297,9 @@ export declare const SuspensionInputSchema: z.ZodObject<{
     key: z.ZodString;
     label: z.ZodString;
     type: z.ZodEnum<{
+        select: "select";
         text: "text";
         textarea: "textarea";
-        select: "select";
     }>;
     placeholder: z.ZodOptional<z.ZodString>;
     required: z.ZodOptional<z.ZodBoolean>;
@@ -253,10 +348,10 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
                 packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 depends_on: z.ZodArray<z.ZodString>;
                 status: z.ZodDefault<z.ZodEnum<{
+                    completed: "completed";
                     failed: "failed";
                     pending: "pending";
                     running: "running";
-                    completed: "completed";
                     skipped: "skipped";
                 }>>;
                 resources: z.ZodOptional<z.ZodObject<{
@@ -266,7 +361,25 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
                         count: z.ZodNumber;
                     }, z.core.$strip>>;
                 }, z.core.$strip>>;
+                grounding: z.ZodOptional<z.ZodObject<{
+                    status: z.ZodEnum<{
+                        flagged: "flagged";
+                        grounded: "grounded";
+                        ungrounded: "ungrounded";
+                    }>;
+                    snapshot: z.ZodString;
+                    claims: z.ZodArray<z.ZodString>;
+                    template: z.ZodOptional<z.ZodString>;
+                    settings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        step: z.ZodString;
+                        name: z.ZodString;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>;
+                        source: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
                 agent: z.ZodOptional<z.ZodString>;
+                capability: z.ZodOptional<z.ZodString>;
                 timeout: z.ZodOptional<z.ZodNumber>;
                 maxSteps: z.ZodNumber;
                 description: z.ZodOptional<z.ZodString>;
@@ -280,7 +393,7 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"json">;
-        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
         label: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"text">;
@@ -288,25 +401,25 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
     }, z.core.$strip>], "type">>>;
     actions: z.ZodArray<z.ZodObject<{
         label: z.ZodString;
-        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
         variant: z.ZodOptional<z.ZodEnum<{
             default: "default";
-            outline: "outline";
             destructive: "destructive";
+            outline: "outline";
         }>>;
         icon: z.ZodOptional<z.ZodEnum<{
+            "alert-circle": "alert-circle";
             check: "check";
             x: "x";
-            "alert-circle": "alert-circle";
         }>>;
     }, z.core.$strip>>;
     inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         label: z.ZodString;
         type: z.ZodEnum<{
+            select: "select";
             text: "text";
             textarea: "textarea";
-            select: "select";
         }>;
         placeholder: z.ZodOptional<z.ZodString>;
         required: z.ZodOptional<z.ZodBoolean>;

package/dist/schemas/workflow-state.js

@@ -6,6 +6,50 @@
  */
 import { z } from "zod";
 // ── Plan structures ─────────────────────────────────────────────────
+/**
+ * One scientific setting of a grounded step: a parameter of the procedure
+ * that `knowledge_recommend` returned, with the procedure step it belongs to
+ * and the source of its value. The host binds the settings to the template
+ * of the step at dispatch, thus a template default never replaces a plan
+ * decision silently.
+ */
+export const GroundingSettingSchema = z.object({
+    step: z.string().describe("The procedure step the setting belongs to (for example `differential_expression` or `normalize`)."),
+    name: z.string().describe("The parameter name as the procedure names it (for example `alpha` or `lfc_shrink`)."),
+    value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]).describe("The value the procedure sets."),
+    source: z.string().optional().describe("The source of the value (a doi or a document) when the procedure names one. Absent otherwise."),
+});
+/**
+ * The grounding of one method step: the claim identifiers and the snapshot
+ * digest that `knowledge_recommend` returned in this run, the template the
+ * step renders, the settings of the procedure, and a one-line reason.
+ * Optional on both step schemas, thus a stored plan and a plan made without
+ * the knowledge service load and validate as before. Phase 0 validates the
+ * shape only. An empty field is visible: the evaluation counts a method step
+ * without a value as ungrounded.
+ */
+export const GroundingSchema = z.object({
+    status: z
+        .enum(["grounded", "ungrounded", "flagged"])
+        .describe("`grounded` when the step follows a returned procedure; `ungrounded` when no rule covered it or the service did not answer; `flagged` when a rule changed the outcome of the step."),
+    snapshot: z.string().describe("The `snapshot.digest` that `knowledge_recommend` returned in this run, or `none`."),
+    claims: z
+        .array(z.string())
+        .describe("The claim identifiers of the step as `knowledge_recommend` returned them (for example `R-0031@e7d0`). Empty when ungrounded."),
+    template: z
+        .string()
+        .optional()
+        .describe("The template id with its version (for example `tpl-deseq2-two-group@1.0.0`) when the step renders a template. Absent otherwise."),
+    settings: z
+        .array(GroundingSettingSchema)
+        .optional()
+        .describe("The scientific settings of the step: the parameters of the procedure steps the plan step holds, as `knowledge_recommend` returned them. " +
+        "Copy the `grounding.settings` of the skeleton step as it is, one entry per parameter, with its step, name, value, and source. " +
+        "Do not restate a setting as prose only, and do not change a value here: state a different value in the step and its reason. Absent when the step is ungrounded."),
+    reason: z
+        .string()
+        .describe("One line: the situation and the method with the rule that selects it, the side chosen for a disputed rule, or why the step is ungrounded or flagged."),
+});
 /**
  * A step of an analysis plan. `PlanStepSchema` (schemas/plan-schemas.ts) narrows
  * this into the planner's output contract and emits it as the `submit_plan`
@@ -52,8 +96,18 @@ export const AnalysisStepSchema = z.object({
     })
         .optional()
         .describe("Resources the step needs. Ground the estimate in the actual data size — see the resource-estimation rules."),
+    grounding: GroundingSchema.optional().describe("The knowledge grounding of a method step: fill it from the answer of `knowledge_recommend` when that tool is attached. Omit it when no knowledge tool is attached."),
     // Execution fields
     agent: z.string().optional().describe("Assigned sandbox agent name from registry"),
+    // Optional on the persistence schema so a plan stored before this field still parses.
+    // `PlanStepSchema` re-requires it for planner output. The launch reads it with the agent id to
+    // resolve what reference data the capability declares — refer to `capabilityDataRequirement`.
+    capability: z
+        .string()
+        .optional()
+        .describe("The one capability phrase of the assigned agent that this step uses, copied EXACTLY from the agent catalog. " +
+        "One phrase, verbatim — never a paraphrase, never a list, never your own wording. " +
+        "The launch resolves the reference data that the capability declares before the run starts, so a reworded phrase loses that check and the step discovers an absent source itself."),
     timeout: z.number().optional().describe("Execution timeout in seconds (falls back to image default)"),
     maxSteps: z.number().describe("Max LLM agentic steps for sandbox agent"),
     description: z.string().optional().describe("Human-readable description of what the step produces."),
@@ -107,7 +161,7 @@ export const ContentBlockSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("plan"), plan: AnalysisPlanSchema }),
     z.object({
         type: z.literal("json"),
-        data: z.record(z.string(), z.unknown()),
+        data: z.record(z.string(), z.json()),
         label: z.string().optional(),
     }),
     z.object({ type: z.literal("text"), text: z.string() }),
@@ -122,7 +176,7 @@ export const ContentBlockSchema = z.discriminatedUnion("type", [
  */
 export const SuspensionActionSchema = z.object({
     label: z.string(),
-    value: z.record(z.string(), z.unknown()),
+    value: z.record(z.string(), z.json()),
     variant: z.enum(["default", "outline", "destructive"]).optional(),
     icon: z.enum(["check", "x", "alert-circle"]).optional(),
 });

package/dist/state/active-turns.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The turn that runs on a thread. The open of a turn claims the thread, and the
+ * end of the turn releases it. A claim whose turn no longer runs, for example
+ * after a cancel, gives way to the next turn.
+ */
+import type { ResultAsync } from "neverthrow";
+import { type DbError } from "../lib/db-result.js";
+import type { Querier } from "./db.js";
+/** The outcome of a claim: the thread is the turn's, another turn that still runs holds it, or no live thread exists. */
+export type TurnClaim = {
+    readonly kind: "claimed";
+} | {
+    readonly kind: "held";
+    readonly turnId: string;
+} | {
+    readonly kind: "no_thread";
+};
+/**
+ * Claim the thread for a turn. `stillRuns` decides if the turn that holds the thread runs. A holder that does not
+ * run gives way. Each update names the holder that it replaces, thus two opens cannot both take the thread.
+ */
+export declare function claimThreadForTurn(pool: Querier, threadId: string, turnId: string, stillRuns: (turnId: string) => Promise<boolean>): ResultAsync<TurnClaim, DbError>;
+/**
+ * Close each turn record of the thread that is still `open`, as `aborted`. A turn that a cancel ended runs no more
+ * code, thus the harness closes its record here. A record that is closed already does not change.
+ */
+export declare function closeOpenTurnRecords(pool: Querier, threadId: string): ResultAsync<void, DbError>;
+/** The turn that runs on the thread of an ask, which waits for its answer. `undefined` when no turn runs there. */
+export declare function turnOfAsk(pool: Querier, askId: string): ResultAsync<string | undefined, DbError>;
+/** The turn that holds each live thread of an analysis. A claim can outlive its turn, thus a caller checks that the turn runs. */
+export declare function queryTurnsOfAnalysis(pool: Querier, analysisId: string): ResultAsync<{
+    readonly threadId: string;
+    readonly turnId: string;
+}[], DbError>;
+/** Release the thread, when the turn still holds it. A second release changes nothing. */
+export declare function releaseThreadOfTurn(pool: Querier, threadId: string, turnId: string): ResultAsync<void, DbError>;

package/dist/state/active-turns.js

@@ -0,0 +1,67 @@
+/**
+ * The turn that runs on a thread. The open of a turn claims the thread, and the
+ * end of the turn releases it. A claim whose turn no longer runs, for example
+ * after a cancel, gives way to the next turn.
+ */
+import { z } from "zod";
+import { tryMutation, tryQuery } from "../lib/db-result.js";
+const HolderRowSchema = z.object({ active_turn_id: z.string().nullable() });
+/** Each attempt reads the holder one time. A holder that changes between two reads takes one more attempt. */
+const CLAIM_ATTEMPTS = 3;
+/**
+ * Claim the thread for a turn. `stillRuns` decides if the turn that holds the thread runs. A holder that does not
+ * run gives way. Each update names the holder that it replaces, thus two opens cannot both take the thread.
+ */
+export function claimThreadForTurn(pool, threadId, turnId, stillRuns) {
+    return tryQuery("activeTurns.claim", async () => {
+        let holder = null;
+        for (let attempt = 0; attempt < CLAIM_ATTEMPTS; attempt++) {
+            const { rows } = await pool.query("SELECT active_turn_id FROM cortex_analysis_threads WHERE thread_id = $1 AND deleted_at IS NULL", [threadId]);
+            const row = rows[0];
+            if (row === undefined)
+                return { kind: "no_thread" };
+            holder = HolderRowSchema.parse(row).active_turn_id;
+            if (holder !== null && holder !== turnId && (await stillRuns(holder)))
+                return { kind: "held", turnId: holder };
+            const taken = await pool.query(`UPDATE cortex_analysis_threads SET active_turn_id = $2
+                  WHERE thread_id = $1 AND active_turn_id IS NOT DISTINCT FROM $3`, [threadId, turnId, holder]);
+            if ((taken.rowCount ?? 0) > 0)
+                return { kind: "claimed" };
+        }
+        return { kind: "held", turnId: holder ?? "" };
+    });
+}
+/**
+ * Close each turn record of the thread that is still `open`, as `aborted`. A turn that a cancel ended runs no more
+ * code, thus the harness closes its record here. A record that is closed already does not change.
+ */
+export function closeOpenTurnRecords(pool, threadId) {
+    return tryMutation("activeTurns.closeOpen", () => pool.query("UPDATE cortex_thread_turns SET status = 'aborted', closed_at = NOW() WHERE thread_id = $1 AND status = 'open'", [threadId])).map(() => undefined);
+}
+const AskTurnRowSchema = z.object({ active_turn_id: z.string().nullable() });
+/** The turn that runs on the thread of an ask, which waits for its answer. `undefined` when no turn runs there. */
+export function turnOfAsk(pool, askId) {
+    return tryQuery("activeTurns.turnOfAsk", async () => {
+        const { rows } = await pool.query(`SELECT threads.active_turn_id FROM cortex_asks asks
+               JOIN cortex_analysis_threads threads ON threads.thread_id = asks.thread_id
+              WHERE asks.id = $1`, [askId]);
+        const row = rows[0];
+        return row === undefined ? undefined : (AskTurnRowSchema.parse(row).active_turn_id ?? undefined);
+    });
+}
+const TurnOfThreadRowSchema = z.object({ thread_id: z.string(), active_turn_id: z.string() });
+/** The turn that holds each live thread of an analysis. A claim can outlive its turn, thus a caller checks that the turn runs. */
+export function queryTurnsOfAnalysis(pool, analysisId) {
+    return tryQuery("activeTurns.ofAnalysis", async () => {
+        const { rows } = await pool.query(`SELECT thread_id, active_turn_id FROM cortex_analysis_threads
+              WHERE analysis_id = $1 AND active_turn_id IS NOT NULL AND deleted_at IS NULL`, [analysisId]);
+        return rows.map((row) => {
+            const parsed = TurnOfThreadRowSchema.parse(row);
+            return { threadId: parsed.thread_id, turnId: parsed.active_turn_id };
+        });
+    });
+}
+/** Release the thread, when the turn still holds it. A second release changes nothing. */
+export function releaseThreadOfTurn(pool, threadId, turnId) {
+    return tryMutation("activeTurns.release", () => pool.query("UPDATE cortex_analysis_threads SET active_turn_id = NULL WHERE thread_id = $1 AND active_turn_id = $2", [threadId, turnId])).map(() => undefined);
+}

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

@@ -10,7 +10,7 @@ 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 {
+export type LatestRunSummary = {
     readonly analysisId: string;
     readonly runId: string;
     readonly status: RunStatus;
@@ -19,26 +19,26 @@ export interface LatestRunSummary {
     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 {
+export type RunProgressSummary = 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 {
+export type 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 {
+export type 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;

package/dist/state/analyses-metrics.js

@@ -146,7 +146,7 @@ export function queryRunsEndedSince(pool, input) {
         const result = await pool.query({
             text: `SELECT analysis_id, run_id, status, completed_at
              FROM cortex_runs
-             WHERE status IN ('completed', 'partial', 'failed', 'canceled', 'suspended_insufficient_funds')
+             WHERE status IN ('completed', 'partial', 'failed', 'canceled')
                AND completed_at >= $1
              ORDER BY completed_at DESC, run_id DESC
              LIMIT $2`,
@@ -185,9 +185,9 @@ export function queryDataProfileStatusByAnalyses(pool, analysisIds) {
             status: r.data_profile_status,
             completedAt: r.data_profile_completed_at ?? null,
             profiledFiles: profileDatasetFileCount({
-                ...(r.partition === null ? {} : { partition: r.partition }),
-                ...(r.coverage === null ? {} : { coverage: r.coverage }),
-                ...(r.kinds === null ? {} : { kinds: r.kinds }),
+                partition: r.partition ?? undefined,
+                coverage: r.coverage ?? undefined,
+                kinds: r.kinds ?? undefined,
             }),
         }));
     });

package/dist/state/analyses.d.ts

@@ -19,17 +19,3 @@ export declare function loadAnalysisStatus(pool: Querier, resourceId: string): R
     status: string;
     context: string | null;
 } | null, DbError>;
-/**
- * Mark an analysis as suspended.
- * Idempotent — no-op if already suspended.
- *
- * `suspended_insufficient_funds` is the name of the one suspended state, for
- * each reason of the host, thus no reason is persisted. A chat turn never calls
- * it.
- */
-export declare function suspendAnalysis(pool: Querier, analysisId: string): ResultAsync<void, DbError>;
-/**
- * Resume a suspended analysis after the user tops up.
- * Only transitions from `suspended_insufficient_funds` → `active`.
- */
-export declare function resumeAnalysis(pool: Querier, analysisId: string): ResultAsync<void, DbError>;

package/dist/state/analyses.js

@@ -40,35 +40,3 @@ export function loadAnalysisStatus(pool, resourceId) {
         return { status: row.status, context: row.context ?? null };
     });
 }
-/**
- * Mark an analysis as suspended.
- * Idempotent — no-op if already suspended.
- *
- * `suspended_insufficient_funds` is the name of the one suspended state, for
- * each reason of the host, thus no reason is persisted. A chat turn never calls
- * it.
- */
-export function suspendAnalysis(pool, analysisId) {
-    return tryMutation("analyses.suspendAnalysis", async () => {
-        await pool.query({
-            text: `UPDATE cortex_analysis_state
-            SET status = 'suspended_insufficient_funds', updated_at = $1
-            WHERE analysis_id = $2 AND status != 'suspended_insufficient_funds'`,
-            values: [new Date().toISOString(), analysisId],
-        });
-    });
-}
-/**
- * Resume a suspended analysis after the user tops up.
- * Only transitions from `suspended_insufficient_funds` → `active`.
- */
-export function resumeAnalysis(pool, analysisId) {
-    return tryMutation("analyses.resumeAnalysis", async () => {
-        await pool.query({
-            text: `UPDATE cortex_analysis_state
-            SET status = 'active', updated_at = $1
-            WHERE analysis_id = $2 AND status = 'suspended_insufficient_funds'`,
-            values: [new Date().toISOString(), analysisId],
-        });
-    });
-}