@inflexa-ai/harness 0.48.3 → 0.48.5

package/dist/runtime/assemble.js

@@ -95,9 +95,10 @@ export function assembleCoreRuntime(deps) {
     const toolOutputStore = createToolOutputStore(conversation.pool);
     const pauseRetryDelaysMs = deps.pauseRetryDelaysMs;
     // Each child of a sub-agent pauses with the work of its caller, thus a resume of the turn or of the run ends its wait.
-    const subAgentPauses = ({ runSession, ...work }, emit) => workPause({
+    const subAgentPauses = ({ runSession, ...work }, waiter, emit) => workPause({
         pool: conversation.pool,
         ...work,
+        waiter,
         emit,
         retryDelaysMs: pauseRetryDelaysMs,
         run: runSession === undefined ? undefined : { session: runSession, authorizer: conversation.runAuthorizer },

package/dist/sandbox/execution-id.js

@@ -7,6 +7,7 @@
  * Format: {sanitizedAgentName}-{nanoid8}  (e.g., qc-agent-a1b2c3d4)
  */
 import { customAlphabet } from "nanoid";
+import { slugify } from "../lib/slug.js";
 /** Length of the nanoid suffix (8 characters). */
 export const EXECUTION_ID_NANOID_LENGTH = 8;
 /** Maximum length for the sanitized agent name portion. */
@@ -27,20 +28,7 @@ const nanoid = customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789");
  * - Truncated to 40 characters
  */
 export function sanitizeAgentName(name) {
-    let out = "";
-    let inRun = false;
-    for (const char of name.toLowerCase()) {
-        const keeps = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-        if (!keeps) {
-            inRun = true;
-            continue;
-        }
-        if (inRun && out.length > 0)
-            out += "-";
-        inRun = false;
-        out += char;
-    }
-    return out.slice(0, AGENT_NAME_MAX_LENGTH);
+    return slugify(name, { maxLength: AGENT_NAME_MAX_LENGTH });
 }
 /**
  * Generate a unified execution ID for an agent invocation.

package/dist/sandbox/leases.js

@@ -109,6 +109,21 @@ export function createSandboxLeases(config) {
         recordMachineReplaced({ cause });
     };
     // ── The lease workflow ────────────────────────────────────────────
+    const waiterOfLease = (input) => {
+        const kind = input.work.kind;
+        switch (kind) {
+            case "profile":
+                return { kind: "profile" };
+            case "run":
+                return { kind: "step", stepId: input.session.runFrame.stepId };
+            case "turn":
+                throw new Error("A chat turn holds no sandbox lease.");
+            default: {
+                const exhaustive = kind;
+                throw new Error(`Unknown work kind: ${String(exhaustive)}`);
+            }
+        }
+    };
     const runLease = async (input) => {
         const log = logger.with({ leaseWorkflowId: input.leaseWorkflowId, ownerWorkflowId: input.ownerWorkflowId });
         const id = input.leaseWorkflowId;
@@ -116,6 +131,7 @@ export function createSandboxLeases(config) {
             pool,
             workId: input.work.id,
             workKind: input.work.kind,
+            waiter: waiterOfLease(input),
             analysisId: input.analysisId,
             // A host reads the streams of the work, not of the lease workflow. The wait of the consumer mirrors the pause.
             emit: () => Promise.resolve(),
@@ -317,9 +333,8 @@ export function createSandboxLeases(config) {
         for (;;) {
             const value = await dbos.getEvent(lease.leaseWorkflowId, key, { timeoutSeconds: WAIT_SLICE_SECONDS, pollingIntervalMs: EVENT_POLL_MS });
             if (value !== null) {
-                if (mirrored !== undefined && mirror !== undefined) {
-                    await mirror({ type: "data-pause", id: lease.leaseWorkflowId, workId: lease.workId, workKind: lease.workKind, state: "running" });
-                }
+                if (mirrored !== undefined && mirror !== undefined)
+                    await mirrorEnd(lease, mirror, mirrored);
                 return value;
             }
             if (await callerCanceled())
@@ -327,33 +342,55 @@ export function createSandboxLeases(config) {
             const status = await dbos.getWorkflow(lease.leaseWorkflowId);
             if (status !== undefined && TERMINAL_STATUSES.has(status.status)) {
                 const last = await dbos.getEvent(lease.leaseWorkflowId, key, { timeoutSeconds: 0 });
-                return last ?? "ended";
+                if (last === null)
+                    return "ended";
+                if (mirrored !== undefined && mirror !== undefined)
+                    await mirrorEnd(lease, mirror, mirrored);
+                return last;
             }
             if (mirror !== undefined)
                 mirrored = await mirrorPause(lease, mirror, mirrored);
         }
     };
+    /**
+     * A lease workflow pauses only at its label gate with the cause `host`, thus its wait is in `paused`, and nothing
+     * but a resume ends it.
+     */
+    const mirrorEnd = (lease, mirror, last) => mirror({
+        type: "data-pause",
+        id: lease.leaseWorkflowId,
+        workId: lease.workId,
+        workKind: lease.workKind,
+        waiter: last.waiter,
+        state: "running",
+        cause: last.cause,
+        pausedAt: last.pausedAt,
+        endedAt: new Date().toISOString(),
+        end: "resume",
+    });
     const mirrorPause = async (lease, mirror, mirrored) => {
         const pauses = unwrapOrThrow(await queryPausesOfWork(pool, lease.analysisId, lease.workId));
         const pause = pauses.find((row) => row.workflowId === lease.leaseWorkflowId);
-        const state = pause === undefined ? undefined : `${pause.state}:${pause.attempt}`;
-        if (state === mirrored)
-            return mirrored;
         if (pause === undefined) {
-            await mirror({ type: "data-pause", id: lease.leaseWorkflowId, workId: lease.workId, workKind: lease.workKind, state: "running" });
+            if (mirrored !== undefined)
+                await mirrorEnd(lease, mirror, mirrored);
             return undefined;
         }
+        if (mirrored?.state === pause.state && mirrored.attempt === pause.attempt && mirrored.pausedAt === pause.pausedAt)
+            return mirrored;
         await mirror({
             type: "data-pause",
             id: lease.leaseWorkflowId,
             workId: lease.workId,
             workKind: lease.workKind,
+            waiter: pause.waiter,
             state: pause.state,
             cause: pause.cause,
+            pausedAt: pause.pausedAt,
             attempt: pause.attempt,
             retryAt: pause.retryAt,
         });
-        return state;
+        return pause;
     };
     const enqueue = async (binding, lease, size) => {
         const dbos = await engine();

package/dist/schemas/validate-plan.js

@@ -17,6 +17,7 @@ import { CycleError, DependencyError, topoSortIntoWaves } from "../execution/top
 import { parseQuery } from "../sandbox/package-identity.js";
 import { isLabelValue } from "../sandbox/labels.js";
 import { isSafeId, STEP_SUBDIRS, SYNTHESIS_STEP_ID } from "../workspace/paths.js";
+import { slugify } from "../lib/slug.js";
 const KNOWN_AGENTS = new Set(KNOWN_AGENT_IDS);
 /**
  * Reserved step-id names. A step id equal to an artifact subdirectory name
@@ -53,20 +54,7 @@ function describeParseError(stepId, entry, error) {
 }
 /** Derive a filesystem-safe output prefix from a step ID. */
 export function deriveOutputPrefix(stepId) {
-    let out = "";
-    let inRun = false;
-    for (const char of stepId.toLowerCase()) {
-        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-        if (!isSlugChar) {
-            inRun = true;
-            continue;
-        }
-        if (inRun && out.length > 0)
-            out += "-";
-        inRun = false;
-        out += char;
-    }
-    return out;
+    return slugify(stepId);
 }
 /**
  * Validate an analysis plan for structural correctness.

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

@@ -27,8 +27,12 @@ export declare function claimThreadForTurn(pool: Querier, threadId: string, turn
 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<{
+/**
+ * The turn that holds each live thread of an analysis, or of each analysis when `analysisId` is absent. A claim can
+ * outlive its turn, thus a caller checks that the turn runs.
+ */
+export declare function queryTurns(pool: Querier, analysisId?: string): ResultAsync<{
+    readonly analysisId: string;
     readonly threadId: string;
     readonly turnId: string;
 }[], DbError>;

package/dist/state/active-turns.js

@@ -49,15 +49,19 @@ export function turnOfAsk(pool, askId) {
         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]);
+const TurnOfThreadRowSchema = z.object({ analysis_id: z.string(), thread_id: z.string(), active_turn_id: z.string() });
+/**
+ * The turn that holds each live thread of an analysis, or of each analysis when `analysisId` is absent. A claim can
+ * outlive its turn, thus a caller checks that the turn runs.
+ */
+export function queryTurns(pool, analysisId) {
+    return tryQuery("activeTurns.list", async () => {
+        const { rows } = await pool.query(`SELECT analysis_id, thread_id, active_turn_id FROM cortex_analysis_threads
+              WHERE ($1::text IS NULL OR analysis_id = $1) AND active_turn_id IS NOT NULL AND deleted_at IS NULL
+              ORDER BY thread_id`, [analysisId ?? null]);
         return rows.map((row) => {
             const parsed = TurnOfThreadRowSchema.parse(row);
-            return { threadId: parsed.thread_id, turnId: parsed.active_turn_id };
+            return { analysisId: parsed.analysis_id, threadId: parsed.thread_id, turnId: parsed.active_turn_id };
         });
     });
 }

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

@@ -240,6 +240,14 @@ export declare function completeEmptyDataProfile(pool: Querier, analysisId: stri
  * (e.g. the seed-first guard in `triggerDataProfile`).
  */
 export declare function loadDataProfileStatus(pool: Querier, analysisId: string): ResultAsync<DataProfileStatus | null, DbError>;
+/**
+ * The data profile that runs in an analysis, or in each analysis when `analysisId` is absent: the row is `running`
+ * and it names its workflow. A caller checks that the workflow is active.
+ */
+export declare function queryRunningProfiles(pool: Querier, analysisId?: string): ResultAsync<{
+    readonly analysisId: string;
+    readonly workflowId: string;
+}[], DbError>;
 /**
  * Read an analysis's raw `seed_input_file_ids`, without the NULL-status collapse
  * {@link loadDataProfileStatus} applies (which hides the seed of any cleared row).

package/dist/state/data-profile.js

@@ -385,6 +385,24 @@ export function loadDataProfileStatus(pool, analysisId) {
         };
     });
 }
+/**
+ * The data profile that runs in an analysis, or in each analysis when `analysisId` is absent: the row is `running`
+ * and it names its workflow. A caller checks that the workflow is active.
+ */
+export function queryRunningProfiles(pool, analysisId) {
+    return tryQuery("dataProfile.queryRunningProfiles", async () => {
+        const result = await pool.query({
+            text: `SELECT analysis_id, data_profile_workflow_id
+            FROM cortex_analysis_state
+            WHERE ($1::text IS NULL OR analysis_id = $1)
+              AND data_profile_status = 'running'
+              AND data_profile_workflow_id IS NOT NULL
+            ORDER BY analysis_id`,
+            values: [analysisId ?? null],
+        });
+        return result.rows.map((row) => ({ analysisId: row.analysis_id, workflowId: row.data_profile_workflow_id }));
+    });
+}
 /**
  * Read an analysis's raw `seed_input_file_ids`, without the NULL-status collapse
  * {@link loadDataProfileStatus} applies (which hides the seed of any cleared row).

package/dist/state/index.d.ts

@@ -18,7 +18,7 @@ export { insertStepExecution, seedStepExecutions, sweepPendingStepExecutions, up
 export type { InsertStepExecutionInput, RunStepCounts, SeedStepExecutionRow, UpdateStepExecutionInput } from "./step-executions.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 { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, queryRunningProfiles, 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";
 export type { DataProfileSummary, EndedRunSummary, LatestRunSummary, RunProgressSummary } from "./analyses-metrics.js";

package/dist/state/index.js

@@ -13,7 +13,7 @@ export { insertRun, reserveRunById, RunDedupCollisionError, RunIdentityCollision
 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, queryPlanPage } from "./plans.js";
-export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, recordDataProfileWorkflowId, } from "./data-profile.js";
+export { tryStartDataProfile, tryRetryDataProfile, tryRerunDataProfile, completeDataProfile, failDataProfile, expireStaleDataProfile, reconcileOrphanedDataProfile, clearDataProfile, completeEmptyDataProfile, loadDataProfileStatus, loadSeedInputFileIds, queryRunningProfiles, 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
 // alone, with the workflow ledger behind an injected seam.

package/dist/state/migrations/20261102120000_record_the_waiter_of_a_pause.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A pause row names what waits. A row that a wait wrote before this column keeps a NULL waiter, which reads as no
+ * waiter, and the migration deletes no row.
+ */
+import type { Migration } from "kysely/migration";
+export declare const recordTheWaiterOfAPause: Migration;

package/dist/state/migrations/20261102120000_record_the_waiter_of_a_pause.js

@@ -0,0 +1,10 @@
+/**
+ * A pause row names what waits. A row that a wait wrote before this column keeps a NULL waiter, which reads as no
+ * waiter, and the migration deletes no row.
+ */
+import { sql } from "kysely";
+export const recordTheWaiterOfAPause = {
+    async up(db) {
+        await sql `ALTER TABLE cortex_paused_work ADD COLUMN IF NOT EXISTS waiter JSONB`.execute(db);
+    },
+};

package/dist/state/migrations/index.js

@@ -24,6 +24,7 @@ import { recordTheRunSessionOfAPause } from "./20261029120100_record_the_run_ses
 import { leaseTheSandboxes } from "./20261030120000_lease_the_sandboxes.js";
 import { dropTheReportDerivations } from "./20261030120100_drop_the_report_derivations.js";
 import { keepTheReportDerivations } from "./20261030120200_keep_the_report_derivations.js";
+import { recordTheWaiterOfAPause } from "./20261102120000_record_the_waiter_of_a_pause.js";
 export function cortexMigrations(logger) {
     return {
         "20260927120000_baseline": baseline(logger),
@@ -45,5 +46,6 @@ export function cortexMigrations(logger) {
         "20261030120000_lease_the_sandboxes": leaseTheSandboxes,
         "20261030120100_drop_the_report_derivations": dropTheReportDerivations,
         "20261030120200_keep_the_report_derivations": keepTheReportDerivations,
+        "20261102120000_record_the_waiter_of_a_pause": recordTheWaiterOfAPause,
     };
 }

package/dist/state/paused-work.d.ts

@@ -5,7 +5,7 @@
 import type { ResultAsync } from "neverthrow";
 import type { QueryConfig } from "pg";
 import type { RunSession } from "../auth/types.js";
-import type { PauseCause, WorkKind } from "../contracts/chat-parts.js";
+import type { PauseCause, PauseWaiter, WorkKind } from "../contracts/chat-parts.js";
 import { type DbError } from "../lib/db-result.js";
 import type { Querier } from "./db.js";
 /** One waiting workflow, as its row records it. */
@@ -13,6 +13,8 @@ export type PauseRecord = {
     readonly workflowId: string;
     readonly workId: string;
     readonly workKind: WorkKind;
+    /** What waits. Absent for a row that a wait wrote before the waiter was recorded. */
+    readonly waiter?: PauseWaiter;
     readonly analysisId: string;
     readonly threadId?: string;
     readonly state: "retrying" | "paused";
@@ -46,7 +48,7 @@ export declare function clearPause(pool: Querier, workflowId: string): ResultAsy
 export declare function clearPauses(pool: Querier, workflowIds: readonly string[]): ResultAsync<void, DbError>;
 /** Delete the rows of each workflow of the work, for a stop of the work. */
 export declare function clearPausesOfWork(pool: Querier, workId: string): ResultAsync<void, DbError>;
-/** The rows of the paused work of an analysis, the oldest pause first. */
-export declare function queryPausesOfAnalysis(pool: PauseRowQuerier, analysisId: string): ResultAsync<PauseRecord[], DbError>;
+/** The rows of the paused work of an analysis, or of each analysis when `analysisId` is absent. The oldest pause is first. */
+export declare function queryPauses(pool: PauseRowQuerier, analysisId?: string): ResultAsync<PauseRecord[], DbError>;
 /** The rows of the waiting workflows of one work in an analysis. */
 export declare function queryPausesOfWork(pool: PauseRowQuerier, analysisId: string, workId: string): ResultAsync<PauseRecord[], DbError>;

package/dist/state/paused-work.js

@@ -3,6 +3,7 @@
  * before it waits and deletes it when the wait ends. A stop of the work deletes the rows of the work.
  */
 import { z } from "zod";
+import { PauseWaiterSchema } from "../contracts/schemas/chat-parts.js";
 import { tryMutation, tryQuery } from "../lib/db-result.js";
 const PauseCauseSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("outage") }),
@@ -13,6 +14,7 @@ const PauseRowSchema = z.object({
     workflow_id: z.string(),
     work_id: z.string(),
     work_kind: z.enum(["turn", "run", "profile"]),
+    waiter: PauseWaiterSchema.nullable(),
     analysis_id: z.string(),
     thread_id: z.string().nullable(),
     state: z.enum(["retrying", "paused"]),
@@ -33,13 +35,14 @@ const PauseRowSchema = z.object({
     })
         .nullable(),
 });
-const COLUMNS = "workflow_id, work_id, work_kind, analysis_id, thread_id, state, cause, attempt, retry_at, topic, paused_at, run_session";
+const COLUMNS = "workflow_id, work_id, work_kind, waiter, analysis_id, thread_id, state, cause, attempt, retry_at, topic, paused_at, run_session";
 function recordOf(row) {
     const parsed = PauseRowSchema.parse(row);
     return {
         workflowId: parsed.workflow_id,
         workId: parsed.work_id,
         workKind: parsed.work_kind,
+        waiter: parsed.waiter ?? undefined,
         analysisId: parsed.analysis_id,
         threadId: parsed.thread_id ?? undefined,
         state: parsed.state,
@@ -54,15 +57,16 @@ function recordOf(row) {
 /** Write the row of a waiting workflow. A workflow waits in one pause at a time, thus a new pause replaces its row. */
 export function recordPause(pool, record) {
     return tryMutation("pausedWork.record", () => pool.query(`INSERT INTO cortex_paused_work (${COLUMNS})
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
              ON CONFLICT (workflow_id) DO UPDATE SET
-               work_id = EXCLUDED.work_id, work_kind = EXCLUDED.work_kind, analysis_id = EXCLUDED.analysis_id,
+               work_id = EXCLUDED.work_id, work_kind = EXCLUDED.work_kind, waiter = EXCLUDED.waiter, analysis_id = EXCLUDED.analysis_id,
                thread_id = EXCLUDED.thread_id, state = EXCLUDED.state, cause = EXCLUDED.cause, attempt = EXCLUDED.attempt,
                retry_at = EXCLUDED.retry_at, topic = EXCLUDED.topic, paused_at = EXCLUDED.paused_at,
                run_session = EXCLUDED.run_session`, [
         record.workflowId,
         record.workId,
         record.workKind,
+        record.waiter === undefined ? null : JSON.stringify(record.waiter),
         record.analysisId,
         record.threadId ?? null,
         record.state,
@@ -86,10 +90,10 @@ export function clearPauses(pool, workflowIds) {
 export function clearPausesOfWork(pool, workId) {
     return tryMutation("pausedWork.clearWork", () => pool.query("DELETE FROM cortex_paused_work WHERE work_id = $1", [workId])).map(() => undefined);
 }
-/** The rows of the paused work of an analysis, the oldest pause first. */
-export function queryPausesOfAnalysis(pool, analysisId) {
-    return tryQuery("pausedWork.ofAnalysis", async () => {
-        const { rows } = await pool.query(`SELECT ${COLUMNS} FROM cortex_paused_work WHERE analysis_id = $1 ORDER BY paused_at, workflow_id`, [analysisId]);
+/** The rows of the paused work of an analysis, or of each analysis when `analysisId` is absent. The oldest pause is first. */
+export function queryPauses(pool, analysisId) {
+    return tryQuery("pausedWork.list", async () => {
+        const { rows } = await pool.query(`SELECT ${COLUMNS} FROM cortex_paused_work WHERE ($1::text IS NULL OR analysis_id = $1) ORDER BY paused_at, workflow_id`, [analysisId ?? null]);
         return rows.map(recordOf);
     });
 }

package/dist/state/runs.d.ts

@@ -99,9 +99,10 @@ export type RunTextFilter = {
  * in step: a new non-terminal status added to one and not the other makes a live run invisible to
  * exactly one of its readers.
  *
- * With `q`, only the runs that the text filter selects are members.
+ * With `q`, only the runs that the text filter selects are members. With no `analysisId`, the runs of each
+ * analysis are members, and each row names its analysis.
  */
-export declare function queryActiveRunsByAnalysis(pool: Querier, analysisId: string, { q }?: RunTextFilter): ResultAsync<CortexRunRow[], DbError>;
+export declare function queryActiveRunsByAnalysis(pool: Querier, analysisId: string | undefined, { q }?: RunTextFilter): ResultAsync<CortexRunRow[], DbError>;
 /**
  * How long a reserved run may wait for its workflow before {@link reconcileOrphanedRuns} fails it. A launch writes
  * the workflow row seconds after the reservation, and the margin covers a slow authorization gate of a managed host.

package/dist/state/runs.js

@@ -165,18 +165,19 @@ function runTextCondition(placeholder) {
  * in step: a new non-terminal status added to one and not the other makes a live run invisible to
  * exactly one of its readers.
  *
- * With `q`, only the runs that the text filter selects are members.
+ * With `q`, only the runs that the text filter selects are members. With no `analysisId`, the runs of each
+ * analysis are members, and each row names its analysis.
  */
 export function queryActiveRunsByAnalysis(pool, analysisId, { q } = {}) {
     return tryQuery("runs.queryActiveRunsByAnalysis", async () => {
-        const values = [analysisId];
+        const values = [analysisId ?? null];
         const text = q === undefined ? "" : `AND ${runTextCondition(`$${values.push(q)}`)}`;
         const result = await pool.query({
             text: `SELECT run_id, analysis_id, thread_id, workflow_name,
                    status, started_at, completed_at, error, synthesis_status, synthesis_reason, parts,
                    mandate_id, plan_id -- oss-core-managed-ok: run-mandate ledger (nullable; OSS leaves null)
             FROM cortex_runs
-            WHERE analysis_id = $1
+            WHERE ($1::text IS NULL OR analysis_id = $1)
               AND status = 'running'
               ${text}
             ORDER BY started_at DESC`,

package/dist/tasks/data-profile-index.js

@@ -21,6 +21,7 @@
  * `workspace_search` documents, so a consumer needs no id parsing to tell them apart.
  */
 import { presentFirst } from "../lib/present.js";
+import { slugify } from "../lib/slug.js";
 import { dimensionCardinalities, profileDimensions, profileFileRecords, profileGroups } from "../app/data-profile-view.js";
 /** Entity entries built for a legacy profile. Past this the entity tier is a liability, not a search aid. */
 export const MAX_ENTITY_ENTRIES = 20_000;
@@ -36,25 +37,10 @@ export const MAX_ENTITY_ENTRIES = 20_000;
 export const PROFILE_INDEX_TYPES = ["input-group", "input-dimension", "input", "input-kind"];
 /** Group names named in one legacy entity entry's text. */
 const MAX_GROUPS_IN_ENTITY_TEXT = 6;
+/** The profile entry slug: capped at 60 characters, and "unnamed" when the name holds no slug character. */
 function slug(value) {
-    let out = "";
-    let inRun = false;
-    for (const char of value.toLowerCase()) {
-        if (out.length >= SLUG_MAX_LENGTH)
-            break;
-        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-        if (!isSlugChar) {
-            inRun = true;
-            continue;
-        }
-        if (inRun && out.length > 0)
-            out += "-";
-        inRun = false;
-        out += char;
-    }
-    return out.slice(0, SLUG_MAX_LENGTH) || "unnamed";
+    return slugify(value, { maxLength: 60, fallback: "unnamed" });
 }
-const SLUG_MAX_LENGTH = 60;
 function slotSummary(slot) {
     return { id: slot.id, location: slot.location, tokenClass: slot.tokenClass, distinctValues: slot.distinctValues };
 }

package/dist/tasks/data-profile-resolve.js

@@ -18,6 +18,7 @@
  */
 import { assessCompleteness } from "../input-scan/companions.js";
 import { presentAt, presentFirst, presentGet } from "../lib/present.js";
+import { slugify } from "../lib/slug.js";
 import { buildSetMenu } from "../input-scan/menu.js";
 import { MAX_SLOT_SAMPLE_VALUES } from "../input-scan/tuning.js";
 import { dimensionScope } from "../contracts/profile-vocabulary.js";
@@ -35,25 +36,10 @@ export const UNCLASSIFIED_GROUP_ID = "unclassified";
 export const MAX_UNCLASSIFIED_RECIPE_PATHS = 1000;
 /** Contested paths named in the accounting before the count stands alone. */
 export const MAX_CONTESTED_SAMPLE = 10;
+/** The recipe group slug: capped at 60 characters, and "group" when the label holds no slug character. */
 function slug(value) {
-    let out = "";
-    let inRun = false;
-    for (const char of value.toLowerCase()) {
-        if (out.length >= SLUG_MAX_LENGTH)
-            break;
-        const isSlugChar = (char >= "a" && char <= "z") || (char >= "0" && char <= "9");
-        if (!isSlugChar) {
-            inRun = true;
-            continue;
-        }
-        if (inRun && out.length > 0)
-            out += "-";
-        inRun = false;
-        out += char;
-    }
-    return out.slice(0, SLUG_MAX_LENGTH) || "group";
+    return slugify(value, { maxLength: 60, fallback: "group" });
 }
-const SLUG_MAX_LENGTH = 60;
 function fileCountOf(members) {
     return members.reduce((total, member) => total + 1 + member.companions.length, 0);
 }

package/dist/tasks/data-profile.js

@@ -418,6 +418,7 @@ export async function runDataProfileBody(input, deps) {
             pool: deps.pool,
             workId: workflowId,
             workKind: "profile",
+            waiter: { kind: "profile" },
             analysisId,
             emit: (part) => DBOS.writeStream("events", part),
             retryDelaysMs: deps.pauseRetryDelaysMs,

package/dist/tools/bio/humanbase.d.ts

@@ -0,0 +1,32 @@
+/**
+ * humanbase — the GIANT tissue-specific functional networks of HumanBase.
+ *
+ * One database, three questions, thus one tool with an `action` (the barrel
+ * rule in `index.ts`). The input is a flat object with an `action` enum, not a
+ * `z.discriminatedUnion`, because model tool calling needs a top-level
+ * `"type":"object"`. The argument of each action is optional in the schema, and
+ * a `.refine` makes it required for its action.
+ *
+ * The GIANT version is not an input: the client derives it from the slug.
+ */
+import { type HumanBaseContext, type HumanBaseNetwork, type HumanBaseScoredContext } from "../lib/humanbase-client.js";
+export type HumanBaseOutput = ({
+    found: true;
+} & HumanBaseNetwork) | {
+    found: false;
+    context: string;
+} | {
+    contexts: HumanBaseScoredContext[];
+    totalFound: number;
+} | {
+    contexts: HumanBaseContext[];
+    totalFound: number;
+};
+export declare const humanbaseTool: import("../define-tool.js").Tool<{
+    action: "contexts" | "network" | "relevant";
+    entrez?: number[] | undefined;
+    context?: string | undefined;
+    nodeSize?: number | undefined;
+    query?: string | undefined;
+    limit?: number | undefined;
+}, HumanBaseOutput>;