@inflexa-ai/harness 0.44.0 → 0.45.0

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>;

package/dist/state/analyses-metrics.js

@@ -1,9 +1,11 @@
 /**
- * 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 { okAsync } from "neverthrow";
+import { profileDatasetFileCount } from "../app/data-profile-view.js";
 import { tryQuery } from "../lib/db-result.js";
 export function queryRunCountsByAnalyses(pool, analysisIds) {
     if (analysisIds.length === 0)
@@ -41,19 +43,152 @@ export function queryThreadCountsByAnalyses(pool, analysisIds) {
         }));
     });
 }
+/** A plan title as text: trimmed with `trim()`, and `null` when it is blank. The SQL gives the title only when it is a string. */
+function titleOf(title) {
+    const trimmed = title?.trim() ?? "";
+    return trimmed === "" ? null : trimmed;
+}
+/**
+ * The columns of a run summary over a run alias `r`, and the plan alias `p` and
+ * the step count alias `s` of `RUN_PROGRESS_JOINS`. The two reads of a run
+ * summary put these after their own selection of `r`, thus the title rule and
+ * the step count rule have one text.
+ */
+const RUN_PROGRESS_COLUMNS = `r.analysis_id, r.run_id, r.status, r.started_at, r.completed_at,
+                    CASE WHEN jsonb_typeof(p.plan->'title') = 'string' THEN p.plan->>'title' END AS plan_title,
+                    s.done_steps, s.total_steps`;
+/** The plan join and the step count subquery for a run alias `r` that selects `analysis_id`, `run_id`, and `plan_id`. */
+const RUN_PROGRESS_JOINS = `LEFT JOIN cortex_plans p ON p.plan_id = r.plan_id AND p.analysis_id = r.analysis_id
+             CROSS JOIN LATERAL (
+                 SELECT COUNT(*)::int AS total_steps,
+                        (COUNT(*) FILTER (WHERE status = 'completed'))::int AS done_steps
+                 FROM cortex_step_executions
+                 WHERE run_id = r.run_id
+             ) s`;
+function toRunSummary(row) {
+    return {
+        analysisId: row.analysis_id,
+        runId: row.run_id,
+        status: row.status,
+        planTitle: titleOf(row.plan_title),
+        doneSteps: row.done_steps,
+        totalSteps: row.total_steps,
+        startedAt: row.started_at,
+        completedAt: row.completed_at,
+    };
+}
+/**
+ * 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 function queryLatestRunsByAnalyses(pool, analysisIds) {
+    if (analysisIds.length === 0)
+        return okAsync([]);
+    return tryQuery("analysesMetrics.queryLatestRunsByAnalyses", async () => {
+        const result = await pool.query({
+            text: `SELECT ${RUN_PROGRESS_COLUMNS}
+             FROM unnest($1::text[]) AS a(id)
+             CROSS JOIN LATERAL (
+                 SELECT analysis_id, run_id, status, started_at, completed_at, plan_id
+                 FROM cortex_runs
+                 WHERE analysis_id = a.id
+                 ORDER BY started_at DESC, run_id DESC
+                 LIMIT 1
+             ) r
+             ${RUN_PROGRESS_JOINS}`,
+            values: [analysisIds],
+        });
+        return result.rows.map(toRunSummary);
+    });
+}
+/**
+ * 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 function queryRunProgressByRuns(pool, runIds) {
+    if (runIds.length === 0)
+        return okAsync([]);
+    return tryQuery("analysesMetrics.queryRunProgressByRuns", async () => {
+        const result = await pool.query({
+            text: `SELECT ${RUN_PROGRESS_COLUMNS}, r.thread_id
+             FROM cortex_runs r
+             ${RUN_PROGRESS_JOINS}
+             WHERE r.run_id = ANY($1::text[])
+             ORDER BY r.started_at DESC, r.run_id DESC`,
+            values: [runIds],
+        });
+        return result.rows.map((row) => ({ ...toRunSummary(row), threadId: row.thread_id }));
+    });
+}
+/**
+ * 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 function queryRunsEndedSince(pool, input) {
+    return tryQuery("analysesMetrics.queryRunsEndedSince", async () => {
+        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')
+               AND completed_at >= $1
+             ORDER BY completed_at DESC, run_id DESC
+             LIMIT $2`,
+            values: [input.since, input.limit],
+        });
+        return result.rows.map((row) => ({
+            analysisId: row.analysis_id,
+            runId: row.run_id,
+            status: row.status,
+            completedAt: row.completed_at,
+        }));
+    });
+}
+/**
+ * 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 function queryDataProfileStatusByAnalyses(pool, analysisIds) {
     if (analysisIds.length === 0)
         return okAsync([]);
     return tryQuery("analysesMetrics.queryDataProfileStatusByAnalyses", async () => {
         const result = await pool.query({
-            text: `SELECT analysis_id, data_profile_status
+            text: `SELECT analysis_id, data_profile_status, data_profile_completed_at,
+                    data_profile_result->'partition' AS partition,
+                    data_profile_result->'coverage' AS coverage,
+                    data_profile_result->'kinds' AS kinds
              FROM cortex_analysis_state
-             WHERE analysis_id = ANY($1::text[])`,
+             WHERE analysis_id = ANY($1::text[]) AND data_profile_status IS NOT NULL`,
             values: [analysisIds],
         });
         return result.rows.map((r) => ({
             analysisId: r.analysis_id,
-            status: r.data_profile_status ?? null,
+            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 }),
+            }),
         }));
     });
 }

package/dist/state/artifacts.d.ts

@@ -5,7 +5,7 @@
 import type { ResultAsync } from "neverthrow";
 import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
-import type { ArtifactRow } from "./schema.js";
+import type { ArtifactRole, ArtifactRow } from "./schema.js";
 export interface RegisterArtifactInput {
     resourceId: string;
     path: string;
@@ -75,8 +75,55 @@ export interface AnalysisArtifactRef {
  * false.
  */
 export declare function queryAnalysisArtifacts(pool: Querier, analysisId: string): ResultAsync<AnalysisArtifactRef[], DbError>;
-/** Count step-output artifacts produced by a run — for the run-completed card. */
-export declare function countArtifactsForRun(pool: Querier, analysisId: string, runId: string): ResultAsync<number, DbError>;
+/** The sort of {@link queryArtifactPage}: `path` is path order, `recent` is newest registration first. */
+export type ArtifactPageSort = "path" | "recent";
+/** The filters, the sort, and the window of {@link queryArtifactPage}. A filter that is absent selects each row. */
+export interface ArtifactPageQuery {
+    runId?: string;
+    stepId?: string;
+    fileType?: string;
+    /** A part of the path, with no regard to case. Each character matches only itself. */
+    q?: string;
+    sort: ArtifactPageSort;
+    limit: number;
+    offset: number;
+}
+/** One ledger row of {@link queryArtifactPage}. */
+export interface ArtifactPageEntry {
+    /** Workspace-root-relative path (`runs/{runId}/{stepId}/output/de.csv`). */
+    path: string;
+    /** Bytes. */
+    size: number;
+    fileType: string | null;
+    role: ArtifactRole;
+    runId: string | null;
+    stepId: string | null;
+    createdAt: string;
+}
+/** One page of the ledger, and the count of the rows that the filters select. */
+export interface ArtifactPage {
+    entries: ArtifactPageEntry[];
+    total: number;
+}
+/**
+ * One page of the artifact ledger of an analysis, in two statements: the count of the rows that the filters
+ * select, and the page. The count is a separate statement because a page past the end has no row to carry it.
+ *
+ * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included. The cost
+ * grows with the ledger of the one analysis, because the count reads each filtered row.
+ */
+export declare function queryArtifactPage(pool: Querier, analysisId: string, query: ArtifactPageQuery): ResultAsync<ArtifactPage, DbError>;
+/** The step-output count of one run, from {@link countArtifactsByRuns}. */
+export interface RunArtifactCount {
+    runId: string;
+    count: number;
+}
+/**
+ * The step-output count of each run of a list, in one statement. A run with no step output has no entry,
+ * and a caller reads it as 0. An `input` row never counts. The run-completed card and a list of runs use
+ * this one rule.
+ */
+export declare function countArtifactsByRuns(pool: Querier, analysisId: string, runIds: readonly string[]): ResultAsync<RunArtifactCount[], DbError>;
 export declare function updateArtifactId(pool: Querier, resourceId: string, path: string, artifactId: string, fileType?: string | null): ResultAsync<void, DbError>;
 export declare function updateFileIds(pool: Querier, pairs: Array<{
     artifactId: string;

package/dist/state/artifacts.js

@@ -179,16 +179,76 @@ export function queryAnalysisArtifacts(pool, analysisId) {
         return result.rows.map((r) => ({ path: r.path, hash: r.hash, fileType: r.file_type ?? null }));
     });
 }
-/** Count step-output artifacts produced by a run — for the run-completed card. */
-export function countArtifactsForRun(pool, analysisId, runId) {
-    return tryQuery("artifacts.countArtifactsForRun", async () => {
+/**
+ * One page of the artifact ledger of an analysis, in two statements: the count of the rows that the filters
+ * select, and the page. The count is a separate statement because a page past the end has no row to carry it.
+ *
+ * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included. The cost
+ * grows with the ledger of the one analysis, because the count reads each filtered row.
+ */
+export function queryArtifactPage(pool, analysisId, query) {
+    return tryQuery("artifacts.queryArtifactPage", async () => {
+        const values = [analysisId];
+        const conditions = ["analysis_id = $1"];
+        const bind = (value) => {
+            values.push(value);
+            return `$${values.length}`;
+        };
+        if (query.runId !== undefined)
+            conditions.push(`source_run = ${bind(query.runId)}`);
+        if (query.stepId !== undefined)
+            conditions.push(`source_step = ${bind(query.stepId)}`);
+        if (query.fileType !== undefined)
+            conditions.push(`file_type = ${bind(query.fileType)}`);
+        // `LIKE` would turn `%` and `_` of the input into wildcards.
+        if (query.q !== undefined)
+            conditions.push(`strpos(lower(path), lower(${bind(query.q)}::text)) > 0`);
+        const where = conditions.join(" AND ");
+        const countResult = await pool.query({
+            text: `SELECT COUNT(*)::int AS total FROM cortex_artifacts WHERE ${where}`,
+            values,
+        });
+        // `path` is unique in one analysis, thus it breaks each tie and two pages never overlap.
+        const order = query.sort === "recent" ? "created_at DESC, path ASC" : "path ASC";
+        const rowsResult = await pool.query({
+            text: `SELECT path, size, file_type, role, source_run, source_step, created_at
+          FROM cortex_artifacts
+          WHERE ${where}
+          ORDER BY ${order}
+          LIMIT ${bind(query.limit)} OFFSET ${bind(query.offset)}`,
+            values,
+        });
+        return {
+            entries: rowsResult.rows.map((r) => ({
+                path: r.path,
+                size: Number(r.size),
+                fileType: r.file_type ?? null,
+                role: r.role,
+                runId: r.source_run ?? null,
+                stepId: r.source_step ?? null,
+                createdAt: r.created_at,
+            })),
+            total: Number(countResult.rows[0]?.total ?? 0),
+        };
+    });
+}
+/**
+ * The step-output count of each run of a list, in one statement. A run with no step output has no entry,
+ * and a caller reads it as 0. An `input` row never counts. The run-completed card and a list of runs use
+ * this one rule.
+ */
+export function countArtifactsByRuns(pool, analysisId, runIds) {
+    return tryQuery("artifacts.countArtifactsByRuns", async () => {
+        if (runIds.length === 0)
+            return [];
         const result = await pool.query({
-            text: `SELECT COUNT(*)::text AS n
+            text: `SELECT source_run, COUNT(*)::int AS n
           FROM cortex_artifacts
-          WHERE analysis_id = $1 AND source_run = $2 AND role = 'step_output'`,
-            values: [analysisId, runId],
+          WHERE analysis_id = $1 AND source_run = ANY($2::text[]) AND role = 'step_output'
+          GROUP BY source_run`,
+            values: [analysisId, [...runIds]],
         });
-        return Number(result.rows[0]?.n ?? 0);
+        return result.rows.map((r) => ({ runId: r.source_run, count: Number(r.n) }));
     });
 }
 export function updateArtifactId(pool, resourceId, path, artifactId, fileType) {

package/dist/state/data-profile.d.ts

@@ -101,12 +101,14 @@ export declare function recordDataProfileWorkflowId(pool: Querier, analysisId: s
  * write per `running` claim, so `stamped: true` is the exactly-once point of a
  * profile's terminal transition. It carries the `data_profile_started_at` of the
  * claim it closed, so the caller measures the profile from the ledger's own start.
+ * It also carries the `data_profile_completed_at` that the write stamped.
  */
 export type DataProfileTerminalWrite = {
     readonly stamped: false;
 } | {
     readonly stamped: true;
     readonly startedAt: string | null;
+    readonly completedAt: string;
 };
 /**
  * Stamp a claimed-`running` row `completed` and record its result — a terminal
@@ -124,7 +126,7 @@ export type DataProfileTerminalWrite = {
  * guard only ever refuses a row another writer already moved on from.
  *
  * `stamped: true` when this call stamped the row, with the `data_profile_started_at`
- * of the claim it closed; `stamped: false` when the guard refused it (the row was
+ * of the claim it closed and the `data_profile_completed_at` it stamped; `stamped: false` when the guard refused it (the row was
  * cleared/expired/replayed away) — a no-op the caller logs, not an error.
  */
 export declare function completeDataProfile(pool: Querier, analysisId: string, result?: DataProfileResult): ResultAsync<DataProfileTerminalWrite, DbError>;
@@ -137,7 +139,7 @@ export declare function completeDataProfile(pool: Querier, analysisId: string, r
  * prior profile survives the failure (the re-profile/retry route can keep serving it).
  *
  * `stamped: true` when this call stamped the row, with the `data_profile_started_at`
- * of the claim it closed; `stamped: false` when the guard refused it — a logged
+ * of the claim it closed and the `data_profile_completed_at` it stamped; `stamped: false` when the guard refused it — a logged
  * no-op, not an error.
  */
 export declare function failDataProfile(pool: Querier, analysisId: string, error: string): ResultAsync<DataProfileTerminalWrite, DbError>;