@inflexa-ai/harness 0.48.0 → 0.48.1

package/dist/index.d.ts

@@ -190,8 +190,8 @@ export { planGraphOf } from "./workflows/plan/graph.js";
 export { planPartOf } from "./memory/card-builders.js";
 export { validatePlan } from "./schemas/validate-plan.js";
 export type { ValidationResult } from "./schemas/validate-plan.js";
-export { upsertPlan, loadPlan, loadPlanRecord } from "./state/plans.js";
-export type { UpsertPlanInput, PlanRecord } from "./state/plans.js";
+export { upsertPlan, loadPlan, loadPlanRecord, queryPlanPage } from "./state/plans.js";
+export type { UpsertPlanInput, PlanRecord, PlanPage, PlanPageEntry } from "./state/plans.js";
 export { insertRun, reserveRunById, queryActiveRun, queryActiveRunsByAnalysis, updateRunStatus, markRunCanceledIfActive, queryRun, queryRunsByAnalysis, countRunsByAnalysis, queryRunIdsByPlan, RunDedupCollisionError, RunIdentityCollisionError, } from "./state/runs.js";
 export type { InsertRunInput, RunReservation } from "./state/runs.js";
 export { queryStepsByRun, countStepsByRuns } from "./state/step-executions.js";

package/dist/index.js

@@ -293,7 +293,7 @@ export { validatePlan } from "./schemas/validate-plan.js";
 // Plan + run + step ledgers around a trigger. `upsertPlan` takes a
 // caller-derived id and inserts-if-absent (the deterministic-id intake path);
 // the run-state calls mirror the chat trigger's reserve → dedup → status flow.
-export { upsertPlan, loadPlan, loadPlanRecord } from "./state/plans.js";
+export { upsertPlan, loadPlan, loadPlanRecord, queryPlanPage } from "./state/plans.js";
 export { insertRun, reserveRunById, queryActiveRun, queryActiveRunsByAnalysis, updateRunStatus, markRunCanceledIfActive, queryRun, queryRunsByAnalysis, countRunsByAnalysis, queryRunIdsByPlan, RunDedupCollisionError, RunIdentityCollisionError, } from "./state/runs.js";
 // The step ledger reads of a run, and the step counts of each run of a list in one statement.
 export { queryStepsByRun, countStepsByRuns } from "./state/step-executions.js";

package/dist/runtime/dbos.d.ts

@@ -98,6 +98,12 @@ export type WorkflowSchedule = {
  * schedule of this list. A second call with the same name replaces the first.
  */
 export declare function scheduleWorkflow(schedule: WorkflowSchedule): void;
+/**
+ * Store each schedule of {@link scheduleWorkflow} in the system database, and delete each stored schedule of this
+ * application that no code registers. DBOS only upserts, thus a schedule of a removed workflow fires on each tick and
+ * finds no function. Each schedule of the harness goes through `scheduleWorkflow`.
+ */
+export declare function applyWorkflowSchedules(): Promise<void>;
 /**
  * Launch DBOS. Idempotent — a second call is a no-op so tests that drive
  * the harness twice (or accidentally double-import) don't re-launch.

package/dist/runtime/dbos.js

@@ -130,6 +130,19 @@ const pendingSchedules = new Map();
 export function scheduleWorkflow(schedule) {
     pendingSchedules.set(schedule.scheduleName, schedule);
 }
+/**
+ * Store each schedule of {@link scheduleWorkflow} in the system database, and delete each stored schedule of this
+ * application that no code registers. DBOS only upserts, thus a schedule of a removed workflow fires on each tick and
+ * finds no function. Each schedule of the harness goes through `scheduleWorkflow`.
+ */
+export async function applyWorkflowSchedules() {
+    if (pendingSchedules.size > 0)
+        await DBOS.applySchedules([...pendingSchedules.values()]);
+    for (const stored of await DBOS.listSchedules()) {
+        if (!pendingSchedules.has(stored.scheduleName))
+            await DBOS.deleteSchedule(stored.scheduleName);
+    }
+}
 let resultRecipesRegistered = false;
 /**
  * DBOS refuses a registration after the launch, and the registry of SuperJSON
@@ -160,8 +173,7 @@ export async function launchDbos({ config, logger: injected }) {
     registerResultSerialization();
     const start = performance.now();
     await DBOS.launch();
-    if (pendingSchedules.size > 0)
-        await DBOS.applySchedules([...pendingSchedules.values()]);
+    await applyWorkflowSchedules();
     state.launched = true;
     state.recoveryStarted = true;
     logger.info("launched", {

package/dist/state/artifacts.d.ts

@@ -86,6 +86,8 @@ export type ArtifactPageQuery = {
     q?: string;
     /** The whole path, with case. It selects the one row of that path. */
     path?: string;
+    /** The role of the row. `step_output` selects the rows that the grouped run count of {@link countArtifactsByRuns} counts. */
+    role?: ArtifactRole;
     /**
      * Extensions in lower case, with no dot. A row is selected when the extension of its path is a member. A row with
      * no extension never matches, and an empty list selects each row. The read compares the members as they are.
@@ -125,7 +127,8 @@ export type ArtifactPage = {
  * select, grouped by extension, and the page. The count is a separate statement because a page past the end has no
  * row to carry it. `total` is the sum of the groups.
  *
- * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included. The cost
+ * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included, unless the `role`
+ * filter selects one role. `total` and `extensionCounts` follow the filters. 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>;

package/dist/state/artifacts.js

@@ -193,7 +193,8 @@ const EXTENSION_SQL = `lower(substring(regexp_replace(path, '^.*/', '') from '^.
  * select, grouped by extension, and the page. The count is a separate statement because a page past the end has no
  * row to carry it. `total` is the sum of the groups.
  *
- * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included. The cost
+ * Every row of the analysis is a member, an `input` row and a row with `unrecoverable_at` included, unless the `role`
+ * filter selects one role. `total` and `extensionCounts` follow the filters. The cost
  * grows with the ledger of the one analysis, because the count reads each filtered row.
  */
 export function queryArtifactPage(pool, analysisId, query) {
@@ -215,6 +216,8 @@ export function queryArtifactPage(pool, analysisId, query) {
             conditions.push(`strpos(lower(path), lower(${bind(query.q)}::text)) > 0`);
         if (query.path !== undefined)
             conditions.push(`path = ${bind(query.path)}`);
+        if (query.role !== undefined)
+            conditions.push(`role = ${bind(query.role)}`);
         if (query.extensions !== undefined && query.extensions.length > 0) {
             conditions.push(`${EXTENSION_SQL} = ANY(${bind([...query.extensions])}::text[])`);
         }

package/dist/state/index.d.ts

@@ -16,8 +16,8 @@ setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis
 export type { InsertRunInput, RunPage, RunReservation } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun, countStepsByRuns, } from "./step-executions.js";
 export type { InsertStepExecutionInput, RunStepCounts, SeedStepExecutionRow, UpdateStepExecutionInput } from "./step-executions.js";
-export { insertPlan, upsertPlan, loadPlan, loadPlanRecord } from "./plans.js";
-export type { InsertPlanInput, UpsertPlanInput, PlanRecord, PlanRowQuerier } from "./plans.js";
+export { insertPlan, upsertPlan, loadPlan, loadPlanRecord, queryPlanPage } from "./plans.js";
+export type { InsertPlanInput, UpsertPlanInput, PlanRecord, PlanRowQuerier, PlanPage, PlanPageEntry } from "./plans.js";
 export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
 export type { DataProfileStatus, DataProfileTerminalWrite, DataProfileResult, DataProfileChecked, DataProfileCompanionCompleteness, DataProfileDimension, DataProfileGroup, DataProfileGroupSlot, DataProfileFile, DataProfileMemberAnnotation, DataProfileObservation, DataProfilePartition, DataProfileProbeReport, DataProfileQualityAssessment, DataProfileQuarantine, DataProfileRecipeStep, DataProfileKind, DataProfileAxis, DataProfileInputSignature, DataProfileCoverage, } from "./data-profile.js";
 export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfileStatusByAnalyses, queryLatestRunsByAnalyses, queryRunProgressByRuns, queryRunsEndedSince, } from "./analyses-metrics.js";

package/dist/state/index.js

@@ -12,7 +12,7 @@ export { upsertArtifact, upsertArtifacts, queryInputArtifacts, queryStepArtifact
 export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollisionError, updateRunStatus, reconcileOrphanedRuns, ORPHANED_RUN_GRACE_MS, markRunCanceledIfActive, promoteFailedToPartial, setRunMandate, // oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
 setRunSynthesisOutcome, queryRun, queryActiveRun, queryNonTerminalRunsByAnalysis, queryRunsForInspection, queryRunsByAnalysis, countRunsByAnalysis, queryRunsByThread, queryRunIdsByPlan, queryNewestPlanRun, } from "./runs.js";
 export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, updateStepExecution, queryStepsByRun, countStepsByRuns, } from "./step-executions.js";
-export { insertPlan, upsertPlan, loadPlan, loadPlanRecord } from "./plans.js";
+export { insertPlan, upsertPlan, loadPlan, loadPlanRecord, queryPlanPage } from "./plans.js";
 export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
 export { queryRunCountsByAnalyses, queryThreadCountsByAnalyses, queryDataProfileStatusByAnalyses, queryLatestRunsByAnalyses, queryRunProgressByRuns, queryRunsEndedSince, } from "./analyses-metrics.js";
 // Not per-entity: one analysis's whole Postgres footprint, reached from its id

package/dist/state/plans.d.ts

@@ -94,3 +94,30 @@ export type PlanRecord = {
 export declare function loadPlanRecord(pool: PlanRowQuerier, planId: string, opts: {
     analysisId: string;
 }): ResultAsync<PlanRecord | null, DbError>;
+/** One plan of {@link queryPlanPage}. */
+export type PlanPageEntry = {
+    planId: string;
+    createdAt: string;
+    /** The `title` of the stored document when it is a string, as the document holds it, else `null`. */
+    title: string | null;
+    parentPlanId: string | null;
+    /** The newest plan of the same analysis that names this plan as its parent. */
+    supersededBy: string | null;
+    /** The newest run of the plan, in the order of {@link queryRunIdsByPlan}, or `null` for a plan with no run. */
+    newestRunId: string | null;
+};
+/** One page of the plans of an analysis, and the exact count of them. */
+export type PlanPage = {
+    entries: PlanPageEntry[];
+    total: number;
+};
+/**
+ * One page of the plans of an analysis, newest first, in two statements: the count of the plans and the page. The
+ * count is a separate statement because a page past the end has no row to carry it. The order is the one of
+ * `supersededBy`: the creation time, then the highest plan id. The page gives the title of the document, not the
+ * document, because a page holds up to 200 plans.
+ */
+export declare function queryPlanPage(pool: Querier, analysisId: string, opts: {
+    limit: number;
+    offset: number;
+}): ResultAsync<PlanPage, DbError>;

package/dist/state/plans.js

@@ -117,6 +117,13 @@ const PlanRecordRowSchema = z.object({
     created_at: z.string(),
     superseded_by: z.string().nullable(),
 });
+/**
+ * The `superseded_by` column of a plan read: the newest plan of the same analysis that names the plan as its parent.
+ * The text refers to the plan row of the outer query as `p`.
+ */
+const SUPERSEDED_BY_SQL = `(SELECT c.plan_id FROM cortex_plans c
+                       WHERE c.parent_plan_id = p.plan_id AND c.analysis_id = p.analysis_id
+                       ORDER BY c.created_at DESC, c.plan_id DESC LIMIT 1) AS superseded_by`;
 /**
  * Analysis-scoped read of one plan with its parent and the newest plan that
  * replaced it, in one statement. Returns `ok(null)` for an unknown planId OR a
@@ -129,9 +136,7 @@ export function loadPlanRecord(pool, planId, opts) {
     return tryQuery("plans.loadPlanRecord", async () => {
         const result = await pool.query({
             text: `SELECT p.plan, p.parent_plan_id, p.created_at,
-                     (SELECT c.plan_id FROM cortex_plans c
-                       WHERE c.parent_plan_id = p.plan_id AND c.analysis_id = p.analysis_id
-                       ORDER BY c.created_at DESC, c.plan_id DESC LIMIT 1) AS superseded_by
+                     ${SUPERSEDED_BY_SQL}
                 FROM cortex_plans p
                WHERE p.plan_id = $1 AND p.analysis_id = $2`,
             values: [planId, opts.analysisId],
@@ -143,3 +148,52 @@ export function loadPlanRecord(pool, planId, opts) {
         return { planId, plan: row.plan, parentPlanId: row.parent_plan_id, supersededBy: row.superseded_by, createdAt: row.created_at };
     });
 }
+const PlanPageRowSchema = z.object({
+    plan_id: z.string(),
+    created_at: z.string(),
+    title: z.string().nullable(),
+    parent_plan_id: z.string().nullable(),
+    superseded_by: z.string().nullable(),
+    newest_run_id: z.string().nullable(),
+});
+/**
+ * One page of the plans of an analysis, newest first, in two statements: the count of the plans and the page. The
+ * count is a separate statement because a page past the end has no row to carry it. The order is the one of
+ * `supersededBy`: the creation time, then the highest plan id. The page gives the title of the document, not the
+ * document, because a page holds up to 200 plans.
+ */
+export function queryPlanPage(pool, analysisId, opts) {
+    return tryQuery("plans.queryPlanPage", async () => {
+        const countResult = await pool.query({
+            text: "SELECT COUNT(*)::int AS total FROM cortex_plans WHERE analysis_id = $1",
+            values: [analysisId],
+        });
+        const rowsResult = await pool.query({
+            text: `SELECT p.plan_id, p.created_at, p.parent_plan_id,
+                     CASE WHEN jsonb_typeof(p.plan->'title') = 'string' THEN p.plan->>'title' END AS title,
+                     ${SUPERSEDED_BY_SQL},
+                     (SELECT r.run_id FROM cortex_runs r
+                       WHERE r.analysis_id = p.analysis_id AND r.plan_id = p.plan_id
+                       ORDER BY r.started_at DESC, r.run_id DESC LIMIT 1) AS newest_run_id
+                FROM cortex_plans p
+               WHERE p.analysis_id = $1
+               ORDER BY p.created_at DESC, p.plan_id DESC
+               LIMIT $2 OFFSET $3`,
+            values: [analysisId, opts.limit, opts.offset],
+        });
+        return {
+            entries: rowsResult.rows.map((raw) => {
+                const row = PlanPageRowSchema.parse(raw);
+                return {
+                    planId: row.plan_id,
+                    createdAt: row.created_at,
+                    title: row.title,
+                    parentPlanId: row.parent_plan_id,
+                    supersededBy: row.superseded_by,
+                    newestRunId: row.newest_run_id,
+                };
+            }),
+            total: countResult.rows[0]?.total ?? 0,
+        };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.48.0",
+    "version": "0.48.1",
     "description": "Host-agnostic bioinformatics agent harness — an agent loop on the AI SDK, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",