@inflexa-ai/harness 0.48.3 → 0.48.4

package/dist/report-model/reference-read.js

@@ -0,0 +1,149 @@
+/**
+ * The reads of a report reference that the two resolver realizations share.
+ *
+ * The fixture resolver reads the rows of a snapshot, and the production resolver reads the rows of the
+ * pinned artifact on disk. What both do with those rows — the locator walk, the table read, and the
+ * derivation arithmetic — lives here, so one semantics exists for both realizations.
+ */
+import { err, ok } from "neverthrow";
+import { asFiniteNumber, cellMatchesFilterValue, checkCitationAssertion, checkValueAssertion } from "./assert-rules.js";
+import { applyRowBound, columnsHeldByNoRow, defineOwn } from "./reference-resolver.js";
+/** Build an `Err` that carries the unresolved reference. The `detail` key is present only when there is a detail to carry. */
+export function fail(reference, reason, detail) {
+    const failure = detail !== undefined ? { reference, reason, detail } : { reference, reason };
+    return err(failure);
+}
+/** A short account of a derivation input, for a detail that names which input broke the arithmetic. */
+function describeReference(reference) {
+    return `artifact value at ${reference.path} column ${reference.locator.column}`;
+}
+/**
+ * Walk a locator over the rows, and give back the one row that it selects, or the failure.
+ *
+ * A row index selects the row at that position. A row filter selects the one row that matches; no match
+ * selects nothing, and two or more matches are ambiguous.
+ */
+export function selectRow(rows, locator) {
+    if (locator.row !== undefined) {
+        const row = rows[locator.row];
+        if (row === undefined) {
+            return err({ reason: "locator-out-of-range", detail: `row ${locator.row} is outside the ${rows.length} rows` });
+        }
+        return ok(row);
+    }
+    if (locator.rowFilter !== undefined) {
+        const filter = locator.rowFilter;
+        const matches = rows.filter((row) => cellMatchesFilterValue(row[filter.column], filter.value));
+        const match = matches[0];
+        if (match === undefined) {
+            return err({ reason: "locator-out-of-range", detail: `no row where ${filter.column} equals ${String(filter.value)}` });
+        }
+        if (matches.length > 1) {
+            return err({ reason: "ambiguous-match", detail: `${matches.length} rows where ${filter.column} equals ${String(filter.value)}` });
+        }
+        return ok(match);
+    }
+    // The locator schema forbids a locator with neither selector. The resolver cannot depend on a
+    // prior parse, thus it treats a row that no selector addresses as out of range.
+    return err({ reason: "locator-out-of-range", detail: "the locator selects no row" });
+}
+/**
+ * Read the table that a table reference addresses out of rows that the caller read from the artifact:
+ * cut the rows on the row bound, refuse a column that no row holds, and project the requested columns.
+ */
+export function readArtifactTable(reference, allRows) {
+    // The bound ranks the rows as the artifact holds them, thus a bound over a column that the subset
+    // below leaves out still ranks them. An unknown bound column addresses nothing, exactly as an
+    // unknown subset column does.
+    const bound = reference.rowBound;
+    if (bound !== undefined && columnsHeldByNoRow(allRows, [bound.column]).length > 0) {
+        return fail(reference, "locator-out-of-range", `the row bound names column ${bound.column}, which the table at ${reference.path} does not hold`);
+    }
+    const rows = bound === undefined ? allRows : applyRowBound(allRows, bound);
+    // The page states the shown count against the count of the artifact. This read is the one place that
+    // holds both, thus a bounded table carries the pre-bound total out with its rows.
+    const total = bound === undefined ? {} : { total: allRows.length };
+    const columns = reference.columns;
+    if (columns === undefined) {
+        return ok({ type: "table", rows, ...total });
+    }
+    // A name that no row holds addresses nothing. Without this check a projection onto an invented column
+    // gives an empty cell for each row and still resolves, which is the fabrication that grounding exists
+    // to reject.
+    const absent = columnsHeldByNoRow(rows, columns);
+    if (absent.length > 0) {
+        return fail(reference, "locator-out-of-range", `the table at ${reference.path} holds no column ${absent.join(", ")}`);
+    }
+    // Project each row onto the requested columns. A table tolerates a ragged row, thus a column that a
+    // given row lacks is left out of that row and is not a failure.
+    const projectedRows = rows.map((row) => {
+        const projected = {};
+        for (const column of columns) {
+            const cell = row[column];
+            if (cell !== undefined) {
+                defineOwn(projected, column, cell);
+            }
+        }
+        return projected;
+    });
+    return ok({ type: "table", rows: projectedRows, columns, ...total });
+}
+/**
+ * Resolve a derivation: read each input with `resolveInput`, then run the arithmetic of the operation.
+ *
+ * The read of an input stays with the realization: the fixture resolver reads its snapshot, and the
+ * production resolver reads the pinned artifact on disk.
+ */
+export async function resolveDerivation(reference, snapshot, resolveInput) {
+    const numbers = [];
+    for (const input of reference.inputs) {
+        const inputResult = await resolveInput(input, snapshot);
+        if (inputResult.isErr()) {
+            // Keep the inner reason so a reviewer sees the real cause, for example a missing artifact under
+            // the derivation. The derivation itself did not fail on its own terms.
+            return fail(reference, inputResult.error.reason, inputResult.error.detail);
+        }
+        const resolved = inputResult.value;
+        const numeric = resolved.type === "scalar" ? asFiniteNumber(resolved.value) : undefined;
+        if (numeric === undefined) {
+            // The arithmetic needs a finite number. A cell that holds text does not address a usable
+            // scalar, thus the closest reason is that the coordinate is out of range.
+            return fail(reference, "locator-out-of-range", `input ${describeReference(input)} did not resolve to a finite number`);
+        }
+        numbers.push(numeric);
+    }
+    const a = numbers[0];
+    const b = numbers[1];
+    if (a === undefined || b === undefined) {
+        return fail(reference, "locator-out-of-range", `operation ${reference.op} needs two inputs, and the derivation holds ${numbers.length}`);
+    }
+    let result;
+    switch (reference.op) {
+        case "ratio":
+            result = a / b;
+            break;
+        case "delta":
+            result = a - b;
+            break;
+        case "pctChange":
+            // A fraction, not a percent. A change of one half gives 0.5, thus an author asserts 0.5 and a
+            // `unit` of `%` only tells a renderer how to show it.
+            result = (a - b) / b;
+            break;
+    }
+    if (!Number.isFinite(result)) {
+        return fail(reference, "locator-out-of-range", `operation ${reference.op} does not yield a finite value, because the divisor is zero`);
+    }
+    const valueFailure = checkValueAssertion(reference, reference.assert?.value, reference.assert?.tolerance, result);
+    return valueFailure !== undefined ? err(valueFailure) : ok({ type: "scalar", value: result });
+}
+/** Resolve a citation: confirm that the id is in the pinned evidence, and echo the key back. */
+export function resolveCitation(reference, snapshot) {
+    const key = `${reference.idKind}:${reference.id}`;
+    if (snapshot.citations === undefined || !snapshot.citations.includes(key)) {
+        return fail(reference, "artifact-missing", `the citation ${key} is not in the pinned evidence`);
+    }
+    const value = { type: "citation", id: key };
+    const citationFailure = checkCitationAssertion(reference, reference.assert?.value, key);
+    return citationFailure !== undefined ? err(citationFailure) : ok(value);
+}

package/dist/report-model/reference-resolver.d.ts

@@ -34,6 +34,13 @@ export type ArtifactSnapshot = {
     fileType?: string | null;
     rows?: Array<Record<string, string | number | null | undefined>>;
 };
+/**
+ * Put one own data property on a row.
+ *
+ * A plain assignment at the key `__proto__` reaches the prototype setter, thus the row loses a column
+ * that the payload carries. The definition makes an own data property for each key.
+ */
+export declare function defineOwn(target: Record<string, string | number>, key: string, value: string | number): void;
 /**
  * Give back the present cells of a snapshot entry's rows, or an empty array for an entry with no rows.
  *

package/dist/report-model/reference-resolver.js

@@ -16,7 +16,7 @@ const CellSchema = z.union([z.string(), z.number()]).nullish();
  * A plain assignment at the key `__proto__` reaches the prototype setter, thus the row loses a column
  * that the payload carries. The definition makes an own data property for each key.
  */
-function defineOwn(target, key, value) {
+export function defineOwn(target, key, value) {
     Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
 }
 /**

package/dist/report-render/chart.js

@@ -888,18 +888,10 @@ function deriveTransformedRows(rows, derived) {
  * parts of a category.
  */
 function deriveBar(block, rows, columns, mode) {
-    const xResult = requireColumn(block, rows, columns, "x");
-    if (xResult.isErr())
-        return err(xResult.error);
-    const yResult = requireColumn(block, rows, columns, "y");
-    if (yResult.isErr())
-        return err(yResult.error);
-    const x = xResult.value;
-    const y = yResult.value;
-    const ordered = orderQuickCategories(block.id, rows, x, block.orders.x);
-    if (ordered.isErr())
-        return err(ordered.error);
-    const categories = ordered.value;
+    const axes = axesOf(block, rows, columns);
+    if (axes.isErr())
+        return err(axes.error);
+    const { x, y, categories } = axes.value;
     const horizontal = block.orientation === "horizontal";
     let series;
     if (mode === "bar") {
@@ -1188,23 +1180,14 @@ function deriveHistogram(block, rows, columns) {
  * point inside the slot of its group.
  */
 function deriveBox(block, rows, columns) {
-    const xResult = requireColumn(block, rows, columns, "x");
-    if (xResult.isErr())
-        return err(xResult.error);
-    const yResult = requireColumn(block, rows, columns, "y");
-    if (yResult.isErr())
-        return err(yResult.error);
-    const x = xResult.value;
-    const y = yResult.value;
-    const ordered = orderQuickCategories(block.id, rows, x, block.orders.x);
-    if (ordered.isErr())
-        return err(ordered.error);
-    const categories = ordered.value;
-    const groupColumn = block.encoding.group;
-    const groups = groupColumn === undefined ? [{ name: undefined }] : firstAppearance(rows.map((row) => row[groupColumn])).map((name) => ({ name }));
-    const bound = slotFault(block.id, categories.length, groups.length);
-    if (bound !== undefined)
-        return err(bound);
+    const axes = axesOf(block, rows, columns);
+    if (axes.isErr())
+        return err(axes.error);
+    const { x, y, categories } = axes.value;
+    const slots = slotGroupsOf(block, rows, categories);
+    if (slots.isErr())
+        return err(slots.error);
+    const { groupColumn, groups } = slots.value;
     const focused = focusSet(block.id, block.focus, rows.length, groups.flatMap((group) => (group.name === undefined ? [] : [group.name])));
     if (focused.isErr())
         return err(focused.error);
@@ -1446,23 +1429,14 @@ function derivePie(block, rows, columns) {
  * violin draws its points on the hidden slot axis, each point inside the slot of its group.
  */
 function deriveViolin(block, rows, columns) {
-    const xResult = requireColumn(block, rows, columns, "x");
-    if (xResult.isErr())
-        return err(xResult.error);
-    const yResult = requireColumn(block, rows, columns, "y");
-    if (yResult.isErr())
-        return err(yResult.error);
-    const x = xResult.value;
-    const y = yResult.value;
-    const ordered = orderQuickCategories(block.id, rows, x, block.orders.x);
-    if (ordered.isErr())
-        return err(ordered.error);
-    const categories = ordered.value;
-    const groupColumn = block.encoding.group;
-    const groups = groupColumn === undefined ? [{ name: undefined }] : firstAppearance(rows.map((row) => row[groupColumn])).map((name) => ({ name }));
-    const bound = slotFault(block.id, categories.length, groups.length);
-    if (bound !== undefined)
-        return err(bound);
+    const axes = axesOf(block, rows, columns);
+    if (axes.isErr())
+        return err(axes.error);
+    const { x, y, categories } = axes.value;
+    const slots = slotGroupsOf(block, rows, categories);
+    if (slots.isErr())
+        return err(slots.error);
+    const { groupColumn, groups } = slots.value;
     const named = groups.flatMap((group) => (group.name === undefined ? [] : [group.name]));
     const focused = focusSet(block.id, block.focus, rows.length, named);
     if (focused.isErr())
@@ -1651,6 +1625,34 @@ function slotFault(blockId, categories, groups) {
         return undefined;
     return problem(blockId, `The chart holds ${categories} categories and ${groups} groups, thus ${slots} slots. A chart holds ${CHART_SLOT_LIMIT} slots at most, thus a table of fewer categories or fewer groups serves the reader.`);
 }
+/**
+ * The x and y columns and the category order that the category derivations share: each one demands both
+ * channels and reads its categories through the quick-path order.
+ */
+function axesOf(block, rows, columns) {
+    const xResult = requireColumn(block, rows, columns, "x");
+    if (xResult.isErr())
+        return err(xResult.error);
+    const yResult = requireColumn(block, rows, columns, "y");
+    if (yResult.isErr())
+        return err(yResult.error);
+    const ordered = orderQuickCategories(block.id, rows, xResult.value, block.orders.x);
+    if (ordered.isErr())
+        return err(ordered.error);
+    return ok({ x: xResult.value, y: yResult.value, categories: ordered.value });
+}
+/**
+ * The slot layout that the box and the violin share: a chart with no group channel holds one unnamed group,
+ * and a layout past the slot limit refuses before any series is built.
+ */
+function slotGroupsOf(block, rows, categories) {
+    const groupColumn = block.encoding.group;
+    const groups = groupColumn === undefined ? [{ name: undefined }] : firstAppearance(rows.map((row) => row[groupColumn])).map((name) => ({ name }));
+    const bound = slotFault(block.id, categories.length, groups.length);
+    if (bound !== undefined)
+        return err(bound);
+    return ok({ groupColumn, groups });
+}
 /** The radius of a radar. The legend and the indicator names sit outside it. */
 const RADAR_RADIUS = "62%";
 /** The tier of one row count. The two counts are constants of the design source. */

package/dist/report-render/figures/common.d.ts

@@ -22,6 +22,40 @@ import { type ChannelOrder, type ChartEncoding, type ChartTransform } from "../.
 import { type ArtifactTableReference, type ColumnMeaning } from "../../contracts/report-reference.js";
 import type { Cell, ChartRow, EchartOption } from "../chart.js";
 import type { RenderProblem } from "../types.js";
+/** The size of one chart box and its text: the page, or one export. */
+export type ChartBox = {
+    readonly widthPx: number;
+    readonly heightPx: number;
+    readonly textPx: number;
+};
+/** The page box, and the export sizes that take a rule of their own: the two journal columns and the slide. */
+export declare const PAGE_BOX: ChartBox;
+export declare const EXPORT_SIZES: readonly [{
+    readonly theme: "inflexa-print";
+    readonly textPx: 9.33;
+    readonly widthPx: 336;
+    readonly heightPx: 253;
+    readonly widthMm: 89;
+    readonly heightMm: 67;
+    readonly pixelRatio: number;
+    readonly label: "89 mm";
+}, {
+    readonly theme: "inflexa-print";
+    readonly textPx: 9.33;
+    readonly widthPx: 692;
+    readonly heightPx: 348;
+    readonly widthMm: 183;
+    readonly heightMm: 92;
+    readonly pixelRatio: number;
+    readonly label: "183 mm";
+}, {
+    readonly theme: "inflexa-slide";
+    readonly textPx: 24;
+    readonly widthPx: 1920;
+    readonly heightPx: 1080;
+    readonly pixelRatio: 1;
+    readonly label: "16:9";
+}];
 /** The display labels that a bound table declares, keyed by the raw column name. */
 export type ColumnLabels = ArtifactTableReference["columnLabels"];
 /** The column meanings that a bound table declares, keyed by the raw column name. */

package/dist/report-render/figures/common.js

@@ -23,9 +23,12 @@ import { channelColumn, channelOrder, channelTransform } from "../../contracts/r
 import { declaredForColumn } from "../../contracts/report-reference.js";
 import { isUnknownArray } from "../../lib/unknown-array.js";
 import { parseUnknownRecord } from "../../lib/unknown-containers.js";
-import { CHART_BODY_MAX_PX, CHART_FONT_STACK, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PALETTE, CHART_WIDE_PALETTE, DIVERGING_RAMP, GUIDE_LINE_COLOR, GUIDE_LINE_WIDTH_PX, MUTED_CHART_COLOR, SEQUENTIAL_RAMP, SIZE_CHANNEL_RANGE_PX, } from "../design.js";
+import { CHART_BODY_MAX_PX, CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_FONT_STACK, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX, CHART_PALETTE, CHART_WIDE_PALETTE, DIVERGING_RAMP, GUIDE_LINE_COLOR, GUIDE_LINE_WIDTH_PX, MUTED_CHART_COLOR, SEQUENTIAL_RAMP, SIZE_CHANNEL_RANGE_PX, } from "../design.js";
 import { formatNumberCell, selectNumberKind, typographicExponent } from "../number-format.js";
 import { STEM_RENDERER } from "../chart-renderers.js";
+/** The page box, and the export sizes that take a rule of their own: the two journal columns and the slide. */
+export const PAGE_BOX = { widthPx: CHART_PAGE_WIDTH_PX, heightPx: CHART_BODY_PX, textPx: CHART_PAGE_TEXT_PX };
+export const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 // ── The cells ───────────────────────────────────────────────────────────────
 /** A typed `invalid-chart-input` problem that names the block and the cause. */
 export function chartProblem(blockId, detail) {

package/dist/report-render/figures/equal-units.js

@@ -22,8 +22,8 @@
  * largest container, thus no other container meets it.
  */
 import { TOOLBOX_BAND_PX } from "../chart-toolbox.js";
-import { CHART_EXPORT_SIZES, CHART_PAGE_TEXT_PX, FACET_COLUMNS } from "../design.js";
-import { legendLineCount, legendLinePx } from "./common.js";
+import { CHART_PAGE_TEXT_PX, FACET_COLUMNS } from "../design.js";
+import { EXPORT_SIZES, legendLineCount, legendLinePx } from "./common.js";
 /** The smallest square side, in pixels. A container smaller than its rule still draws this square. */
 const SQUARE_MIN_PX = 120;
 /** The largest square side, in pixels. The slide export is the largest container. */
@@ -83,8 +83,6 @@ export function squareLayout(fields) {
         media,
     };
 }
-/** The export sizes that take a rule of their own: the two journal columns and the slide. */
-const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 /** The scale of the margins of a page square: one up to the page square, and larger with a larger square. */
 function marginScale(side) {
     return Math.min(MARGIN_SCALE_MAX, Math.max(1, side / MARGIN_SCALE_FROM_PX));

package/dist/report-render/figures/sankey.js

@@ -25,7 +25,7 @@
 import { err, ok } from "neverthrow";
 import { declaredForColumn } from "../../contracts/report-reference.js";
 import { CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX, MUTED_CHART_COLOR } from "../design.js";
-import { AREA_LEGEND_ICON, categoricalPalette, chartProblem, demandedColumn, firstAppearance, legendLineCount, legendLinePx, plainColumn, toNumber, } from "./common.js";
+import { AREA_LEGEND_ICON, categoricalPalette, chartProblem, demandedColumn, EXPORT_SIZES, firstAppearance, legendLineCount, legendLinePx, PAGE_BOX, plainColumn, toNumber, } from "./common.js";
 import { largest } from "./dense.js";
 /** The opacity of a flow. A flow reads as the path of its source, and a label reads over it. */
 export const SANKEY_LINK_OPACITY = 0.35;
@@ -182,8 +182,6 @@ function readFlows(rows, source, target, value, group) {
     }
     return ok(flows);
 }
-const PAGE_BOX = { widthPx: CHART_PAGE_WIDTH_PX, heightPx: CHART_BODY_PX, textPx: CHART_PAGE_TEXT_PX };
-const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 /**
  * The text and the node size of one box: the label text size, the room of a label between two stages, the node
  * width, and the node gap. A figure of one stage gives its label the half of the width.

package/dist/report-render/figures/upset.js

@@ -25,8 +25,8 @@
  * each export size states the dot size and the turn of the count text there.
  */
 import { err, ok } from "neverthrow";
-import { CHART_BODY_PX, CHART_EXPORT_SIZES, CHART_INK, CHART_PAGE_TEXT_PX, CHART_PAGE_WIDTH_PX } from "../design.js";
-import { axisNameFields, chartProblem, demandedColumn, valueAxis } from "./common.js";
+import { CHART_EXPORT_SIZES, CHART_INK } from "../design.js";
+import { axisNameFields, chartProblem, demandedColumn, EXPORT_SIZES, PAGE_BOX, valueAxis } from "./common.js";
 /**
  * The most sets that one figure draws. Each set takes one row of the matrix, and the rows of twelve sets hold
  * one line of the column-export text each.
@@ -125,9 +125,6 @@ function compareMembers(a, b) {
     }
     return a.length - b.length;
 }
-/** The page box and the box of each export size. */
-const PAGE_BOX = { widthPx: CHART_PAGE_WIDTH_PX, heightPx: CHART_BODY_PX, textPx: CHART_PAGE_TEXT_PX };
-const EXPORT_SIZES = [CHART_EXPORT_SIZES.single, CHART_EXPORT_SIZES.double, CHART_EXPORT_SIZES.slide];
 /**
  * The places of the grids for some sets, and set names of some length.
  *

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).