@inflexa-ai/harness 0.45.1 → 0.46.0

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

@@ -17,6 +17,7 @@
  * the profile cover" stops being a question and becomes a census.
  */
 import { assessCompleteness } from "../input-scan/companions.js";
+import { presentAt, presentFirst, presentGet } from "../lib/present.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,12 +36,24 @@ export const MAX_UNCLASSIFIED_RECIPE_PATHS = 1000;
 /** Contested paths named in the accounting before the count stands alone. */
 export const MAX_CONTESTED_SAMPLE = 10;
 function slug(value) {
-    return (value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "")
-        .slice(0, 60) || "group");
+    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";
 }
+const SLUG_MAX_LENGTH = 60;
 function fileCountOf(members) {
     return members.reduce((total, member) => total + 1 + member.companions.length, 0);
 }
@@ -82,13 +95,13 @@ function narrowSlot(slot, values) {
         tokenClass: slot.tokenClass,
         distinctValues: distinct.length,
         sampleValues: distinct.slice(0, MAX_SLOT_SAMPLE_VALUES),
-        ...(slot.sameAsSlot ? { sameAsSlot: slot.sameAsSlot } : {}),
+        sameAsSlot: slot.sameAsSlot,
     };
 }
 function groupSlots(detected, draft, claims) {
     const slots = [];
     for (const set of draft.sets) {
-        const indices = claims.filter((claim) => claim.set?.id === set.id && claim.memberIndex !== undefined).map((claim) => claim.memberIndex);
+        const indices = claims.flatMap((claim) => (claim.set?.id === set.id && claim.memberIndex !== undefined ? [claim.memberIndex] : []));
         for (const slot of set.slots) {
             const values = detected.memberSlotValues.get(slot.id);
             if (!values)
@@ -103,39 +116,40 @@ function finalizeGroup(detected, draft, id, claims) {
     const { annotation } = draft;
     const { completeness } = assessCompleteness(members);
     const slots = groupSlots(detected, draft, claims);
-    return {
+    const group = {
         id,
         name: draft.nameOverride ?? annotation.name,
         memberRepresents: annotation.memberRepresents,
         description: annotation.description,
         role: annotation.role,
         category: annotation.category,
-        ...(annotation.categoryLabel ? { categoryLabel: annotation.categoryLabel } : {}),
-        ...(annotation.subtype ? { subtype: annotation.subtype } : {}),
-        ...(annotation.categoryReason ? { categoryReason: annotation.categoryReason } : {}),
-        ...(draft.reason ? { reason: draft.reason } : {}),
+        categoryLabel: annotation.categoryLabel ? annotation.categoryLabel : undefined,
+        subtype: annotation.subtype ? annotation.subtype : undefined,
+        categoryReason: annotation.categoryReason ? annotation.categoryReason : undefined,
+        reason: draft.reason ? draft.reason : undefined,
         count: members.length,
         fileCount: fileCountOf(members),
         totalBytes: bytesOf(members),
         displayPattern: draft.displayPattern,
         formats: formatCensus(members),
-        ...(slots.length > 0 ? { slots } : {}),
-        ...(annotation.memberAnnotations && annotation.memberAnnotations.length > 0
-            ? { memberAnnotations: annotation.memberAnnotations.map((entry) => ({ path: entry.path, note: entry.note })) }
-            : {}),
-        ...(completeness.expectedCompanions.length > 0
+        memberAnnotations: annotation.memberAnnotations !== undefined && annotation.memberAnnotations.length > 0
+            ? annotation.memberAnnotations.map((entry) => ({ path: entry.path, note: entry.note }))
+            : undefined,
+        completeness: completeness.expectedCompanions.length > 0
             ? {
-                completeness: {
-                    expectedCompanions: [...completeness.expectedCompanions],
-                    completeMembers: completeness.completeMembers,
-                    incompleteMembers: completeness.incompleteMembers,
-                    incompleteSample: completeness.incompleteSample.map((entry) => ({ path: entry.path, missingCompanions: [...entry.missingCompanions] })),
-                },
+                expectedCompanions: [...completeness.expectedCompanions],
+                completeMembers: completeness.completeMembers,
+                incompleteMembers: completeness.incompleteMembers,
+                incompleteSample: completeness.incompleteSample.map((entry) => ({ path: entry.path, missingCompanions: [...entry.missingCompanions] })),
             }
-            : {}),
-        ...(draft.unclassified ? { unclassified: true } : {}),
+            : undefined,
         memberPaths: members.map((member) => member.path),
     };
+    if (slots.length > 0)
+        group.slots = slots;
+    if (draft.unclassified)
+        group.unclassified = true;
+    return group;
 }
 /** The residue group. Authored by nobody, which is exactly why it says so. */
 function unclassifiedDraft(claims) {
@@ -177,7 +191,7 @@ function allClaims(set) {
     return set.members.map((member, index) => ({ member, set, memberIndex: index }));
 }
 function claimsAt(set, indices) {
-    return indices.map((index) => ({ member: set.members[index], set, memberIndex: index }));
+    return indices.map((index) => ({ member: presentAt(set.members, index, "the claimed member"), set, memberIndex: index }));
 }
 function applyUse(ctx, op) {
     const set = resolveSet(ctx, op.setId, "use");
@@ -220,7 +234,7 @@ function applySplit(ctx, op) {
                 reason: op.reason,
                 displayPattern: set.pathTemplate,
                 sets: [set],
-                claims: claimsAt(set, byValue.get(value)),
+                claims: claimsAt(set, presentGet(byValue, value, `the members with value "${value}"`)),
                 splitValues: [value],
             });
         }
@@ -263,7 +277,7 @@ function applySplit(ctx, op) {
     if (restValues.length === 0)
         return;
     if (!op.by.rest) {
-        const restMembers = restValues.reduce((total, value) => total + byValue.get(value).length, 0);
+        const restMembers = restValues.reduce((total, value) => total + presentGet(byValue, value, `the members with value "${value}"`).length, 0);
         ctx.errors.push(`split ${op.setId} by ${slot.id}: ${restMembers} members take a value the mapping did not name. ` +
             'Name the remaining values, or add a "rest" group for them.');
         return;
@@ -273,7 +287,7 @@ function applySplit(ctx, op) {
         reason: op.reason,
         displayPattern: set.pathTemplate,
         sets: [set],
-        claims: claimsAt(set, restValues.flatMap((value) => byValue.get(value))),
+        claims: claimsAt(set, restValues.flatMap((value) => presentGet(byValue, value, `the members with value "${value}"`))),
         splitValues: restValues,
     });
 }
@@ -320,7 +334,7 @@ function applyGroup(ctx, op) {
     const entry = openStep(ctx, { op: "group", templates: [], paths: [...op.paths], groupIds: [] });
     emit(ctx, entry, {
         annotation: op.group,
-        displayPattern: paths.length === 1 ? paths[0] : `${commonDirectory(paths) || "."}/… (${paths.length} paths)`,
+        displayPattern: paths.length === 1 ? presentFirst(paths, "the single path") : `${commonDirectory(paths) || "."}/… (${paths.length} paths)`,
         sets: [],
         claims,
     });
@@ -351,7 +365,7 @@ function resolveObservation(observation, ctx) {
         return undefined;
     }
     const values = ctx.detected.slotValues.get(slot.id) ?? [];
-    return {
+    const resolvedObservation = {
         kind: "slot",
         groupIds: [...(ctx.groupsBySet.get(set.id) ?? [])],
         slotId: slot.id,
@@ -362,8 +376,10 @@ function resolveObservation(observation, ctx) {
         tokenClass: slot.tokenClass,
         cardinality: slot.distinctValues,
         sampleValues: [...values].sort((a, b) => a.localeCompare(b, "en")).slice(0, MAX_SLOT_SAMPLE_VALUES),
-        ...(observation.note ? { note: observation.note } : {}),
     };
+    if (observation.note)
+        resolvedObservation.note = observation.note;
+    return resolvedObservation;
 }
 /** Every slot of the scan, keyed by id — the scanner's own view of what a slot observation points at. */
 function slotsById(detected) {
@@ -388,7 +404,7 @@ function slotsById(detected) {
  */
 function crossCheckSlots(detected, observations) {
     const reference = observations.find((observation) => observation.kind === "slot");
-    if (!reference || reference.kind !== "slot")
+    if (!reference)
         return [...observations];
     const byId = slotsById(detected);
     const referenceSlot = byId.get(reference.slotId);
@@ -402,7 +418,7 @@ function crossCheckSlots(detected, observations) {
             return {
                 ...observation,
                 sameAsSlot: reference.slotId,
-                ...(linked?.crossCheckMismatches !== undefined ? { sameAsSlotMismatches: linked.crossCheckMismatches } : {}),
+                sameAsSlotMismatches: linked?.crossCheckMismatches,
             };
         }
         if (referenceValues.size === 0)
@@ -432,24 +448,28 @@ function resolveDimensions(submission, detected, menuSets, groupsBySet, errors)
             errors.push(`dimension "${dimension.label}": every observation failed to resolve, so nothing evidences it.`);
             continue;
         }
-        resolved.push({
+        const reconciliations = dimension.reconciliations !== undefined && dimension.reconciliations.length > 0
+            ? dimension.reconciliations.map((entry) => ({
+                note: entry.note,
+                delta: entry.delta,
+            }))
+            : undefined;
+        const resolvedDimension = {
             label: dimension.label,
             category: dimension.category,
-            ...(dimension.categoryLabel ? { categoryLabel: dimension.categoryLabel } : {}),
             scope: dimensionScope(dimension.category, dimension.scope),
-            ...(dimension.description ? { description: dimension.description } : {}),
             observations: crossCheckSlots(detected, observations),
-            ...(dimension.reconciliations && dimension.reconciliations.length > 0
-                ? {
-                    reconciliations: dimension.reconciliations.map((entry) => ({
-                        note: entry.note,
-                        ...(entry.delta !== undefined ? { delta: entry.delta } : {}),
-                    })),
-                }
-                : {}),
-            ...(dimension.nestsUnder ? { nestsUnder: { ...dimension.nestsUnder } } : {}),
-            ...(dimension.treatmentReason ? { treatmentReason: dimension.treatmentReason } : {}),
-        });
+            nestsUnder: dimension.nestsUnder === undefined ? undefined : { ...dimension.nestsUnder },
+        };
+        if (dimension.categoryLabel)
+            resolvedDimension.categoryLabel = dimension.categoryLabel;
+        if (dimension.description)
+            resolvedDimension.description = dimension.description;
+        if (dimension.treatmentReason)
+            resolvedDimension.treatmentReason = dimension.treatmentReason;
+        if (reconciliations)
+            resolvedDimension.reconciliations = reconciliations;
+        resolved.push(resolvedDimension);
     }
     return resolved;
 }
@@ -509,7 +529,7 @@ export function resolveProfileSubmission(submission, detected, menu = buildSetMe
     const claimsByDraft = new Map();
     const claimants = new Map();
     for (const draft of ctx.drafts) {
-        const id = ids.get(draft);
+        const id = presentGet(ids, draft, "the group id of the draft");
         const seen = new Set();
         const kept = [];
         for (const claim of draft.claims) {
@@ -546,14 +566,14 @@ export function resolveProfileSubmission(submission, detected, menu = buildSetMe
         }
         else {
             for (const path of contested) {
-                const owners = claimants.get(path);
-                errors.push(`"${path}" is claimed by both "${owners[0]}" and "${owners[1]}". A kept file belongs to exactly one group.`);
+                const owners = presentGet(claimants, path, `the claimants of "${path}"`);
+                errors.push(`"${path}" is claimed by both "${String(owners[0])}" and "${String(owners[1])}". A kept file belongs to exactly one group.`);
             }
             // The repair round decides who keeps it. Until then the first claimant holds it,
             // so the accounting handed back to the agent still sums.
             for (const [draft, kept] of claimsByDraft) {
-                const id = ids.get(draft);
-                claimsByDraft.set(draft, kept.filter((claim) => !disputed.has(claim.member.path) || claimants.get(claim.member.path)[0] === id));
+                const id = presentGet(ids, draft, "the group id of the draft");
+                claimsByDraft.set(draft, kept.filter((claim) => !disputed.has(claim.member.path) || presentGet(claimants, claim.member.path, `the claimants of "${claim.member.path}"`)[0] === id));
             }
         }
     }
@@ -564,29 +584,34 @@ export function resolveProfileSubmission(submission, detected, menu = buildSetMe
     const unclaimed = [...byPath.keys()].filter((path) => !claimed.has(path)).sort((a, b) => a.localeCompare(b, "en"));
     const drafts = [...ctx.drafts];
     if (unclaimed.length > 0) {
-        const residue = unclassifiedDraft(unclaimed.map((path) => byPath.get(path)));
+        const residue = unclassifiedDraft(unclaimed.map((path) => presentGet(byPath, path, `the entry for "${path}"`)));
         drafts.push(residue);
         ids.set(residue, UNCLASSIFIED_GROUP_ID);
         claimsByDraft.set(residue, [...residue.claims]);
     }
     for (const entry of ctx.recipe) {
-        entry.step.groupIds = entry.drafts.map((draft) => ids.get(draft));
+        entry.step.groupIds = entry.drafts.map((draft) => presentGet(ids, draft, "the group id of the draft"));
         if (entry.step.op === "split") {
-            entry.step.valueMapping = entry.drafts.map((draft) => ({ groupId: ids.get(draft), values: [...(draft.splitValues ?? [])] }));
+            entry.step.valueMapping = entry.drafts.map((draft) => ({
+                groupId: presentGet(ids, draft, "the group id of the draft"),
+                values: [...(draft.splitValues ?? [])],
+            }));
         }
     }
     const recipe = ctx.recipe.map((entry) => entry.step);
     if (unclaimed.length > 0) {
         const paths = unclaimed.slice(0, MAX_UNCLASSIFIED_RECIPE_PATHS);
-        recipe.push({
+        const sweep = {
             op: "unclassified",
             templates: [],
             paths,
-            ...(unclaimed.length > paths.length ? { pathsTruncated: true } : {}),
             groupIds: [UNCLASSIFIED_GROUP_ID],
-        });
+        };
+        if (unclaimed.length > paths.length)
+            sweep.pathsTruncated = true;
+        recipe.push(sweep);
     }
-    const groups = drafts.map((draft) => finalizeGroup(detected, draft, ids.get(draft), claimsByDraft.get(draft) ?? []));
+    const groups = drafts.map((draft) => finalizeGroup(detected, draft, presentGet(ids, draft, "the group id of the draft"), claimsByDraft.get(draft) ?? []));
     const unclassifiedGroup = groups.find((group) => group.unclassified);
     const partition = {
         scannedFiles: detected.fileCount,
@@ -601,9 +626,10 @@ export function resolveProfileSubmission(submission, detected, menu = buildSetMe
             reasons: detected.quarantine.reasons.map((entry) => ({ reason: entry.reason, count: entry.count })),
             sample: [...detected.quarantine.sample],
         },
-        ...(contested.length > 0 ? { contested: { members: contested.length, sample: contested.slice(0, MAX_CONTESTED_SAMPLE) } } : {}),
-        ...(menu.truncated ? { scanTruncated: true } : {}),
+        contested: contested.length > 0 ? { members: contested.length, sample: contested.slice(0, MAX_CONTESTED_SAMPLE) } : undefined,
     };
+    if (menu.truncated)
+        partition.scanTruncated = true;
     return {
         errors,
         unclaimed,

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

@@ -18,16 +18,17 @@
  * UPDATE wins); each winning attempt starts a workflow under a per-attempt id.
  */
 import { ResultAsync } from "neverthrow";
-import type { Pool } from "pg";
 import { type AuthContext, type RunSession } from "../auth/types.js";
 import type { EnvironmentStorePaths } from "../config/environment-stores.js";
 import type { ExtendAnalysisFarm } from "../sandbox/types.js";
-import type { RunAuthorization, RunAuthorizer } from "../execution/run-authorizer.js";
+import type { RunAuthorizer } from "../execution/run-authorizer.js";
+import type { RunLauncher } from "../execution/run-launcher.js";
 import type { StagedInput } from "../execution/staged-input.js";
 import type { SandboxAgentDeps } from "../agents/sandbox/shared.js";
 import type { BioToolKeys } from "../tools/bio/keys.js";
 import type { ToolOutputStore } from "../loop/tool-output.js";
 import type { DbError } from "../lib/db-result.js";
+import type { Querier } from "../state/db.js";
 import { type GateRefusal, type NoticeFailure } from "../lib/hooks.js";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
@@ -39,20 +40,20 @@ import { type ProfileSubmission } from "../schemas/data-profile-schemas.js";
 import { type ProfileResolution } from "./data-profile-resolve.js";
 import { type DataProfileResult } from "../state/index.js";
 /** The settle of one profile claim: the ledger row left `running`, and the terminal write stamped it. */
-export interface DataProfileSettlement {
+export type DataProfileSettlement = {
     readonly analysisId: string;
     readonly status: "completed" | "failed";
     /** The `data_profile_completed_at` that the terminal write stamped, as an ISO 8601 string. */
     readonly completedAt: string;
-}
+};
 /** The notice of a profile settle. The workflow body calls it one time for each settled claim. */
 export type NotifyDataProfileSettled = (settlement: DataProfileSettlement) => ResultAsync<void, NoticeFailure>;
 /** The body's construction-time deps — closed over at registration. */
-export interface DataProfileDeps extends EnvironmentStorePaths {
+export type DataProfileDeps = EnvironmentStorePaths & {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
     readonly provider: ChatProvider;
-    readonly pool: Pool;
+    readonly pool: Querier;
     readonly sandboxClient: SandboxClient;
     readonly workspaceFs: WorkspaceFilesystem;
     /** Workspace-root resolution seam (see workspace/paths.ts). */
@@ -87,13 +88,15 @@ export interface DataProfileDeps extends EnvironmentStorePaths {
      * body calls nothing. It is not a provenance hook.
      */
     readonly notifyDataProfileSettled?: NotifyDataProfileSettled;
-}
+    /** The delays of the timer of an outage. Absent: the default of the pause. */
+    readonly pauseRetryDelaysMs?: readonly number[];
+};
 /**
  * Workflow input. JSON-serialisable — DBOS persists it as the workflow's
  * input row. The `RunSession` carries the run authorization; the body reads it
  * and never mints.
  */
-export interface DataProfileWorkflowInput {
+export type DataProfileWorkflowInput = {
     readonly analysisId: string;
     readonly runSession: RunSession;
     /**
@@ -103,19 +106,7 @@ export interface DataProfileWorkflowInput {
      * DBOS workflow input and survives recovery.
      */
     readonly stagedInputs: readonly StagedInput[];
-    /**
-     * True when Cortex owns the run-authorization lifecycle and therefore must
-     * revoke it on every terminal path. False when the caller supplied its own
-     * authorization: the caller owns the lifecycle, so the body must NOT revoke
-     * it. The ownership decision is made by the `RunAuthorizer` seam — see
-     * `authorizeDataProfile`.
-     *
-     * Optional because a workflow persisted before this field existed (recovered
-     * across the deploy that added it) deserializes without it; the body defaults
-     * absent → true, matching the prior Cortex-owned behavior.
-     */
-    readonly ownsMandate?: boolean;
-}
+};
 /**
  * Project the profiler's structured output plus the staged manifest into the record
  * persisted on `cortex_analysis_state`.
@@ -145,7 +136,7 @@ export declare function buildDataProfileResult(submission: ProfileSubmission, re
 export declare function buildAbsorbedResult(prior: DataProfileResult, resolution: ProfileResolution, stagedInputs: readonly StagedInput[], profiledAt: string): DataProfileResult;
 /**
  * Register the data-profile workflow with DBOS. Returns the registered
- * callable so `triggerDataProfile` can dispatch via `DBOS.startWorkflow`.
+ * callable so `triggerDataProfile` can dispatch it through the run launcher.
  */
 /**
  * Project the workflow deps onto the profiler agent bag. The farm-extension
@@ -192,31 +183,35 @@ export declare function describeDataProfileStartError(e: DataProfileStartError):
  * construction-time deps are closed over at registration
  * (`registerDataProfileWorkflow`); the route never holds them.
  */
-export interface DataProfileTriggerDeps {
+export type DataProfileTriggerDeps = {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
-    readonly pool: Pool;
+    readonly pool: Querier;
     readonly runAuthorizer: RunAuthorizer;
+    /**
+     * Starts the profile workflow. A tool call of a chat turn runs in a step, and DBOS refuses a workflow start
+     * inside a step, thus the start goes through the launcher, which enqueues there.
+     */
+    readonly runLauncher: RunLauncher;
     readonly workflow: (input: DataProfileWorkflowInput) => Promise<void>;
-}
+};
 /**
  * Identity + staged inputs for a profile run. The caller (the managed route /
  * the CLI) stages `data/inputs/` BEFORE triggering (see the data-profile-init spec) and passes the
  * resulting manifest here; this trigger never stages — it forwards the manifest
  * into the workflow input.
  */
-export interface DataProfileTriggerParams {
+export type DataProfileTriggerParams = {
     readonly auth: AuthContext;
     readonly analysisId: string;
     readonly stagedInputs: readonly StagedInput[];
-}
+};
 /**
  * Resolve the `RunSession` the workflow runs under. Whether the authorization
- * is freshly minted (Cortex-owned) or reused (caller-owned) is decided by the
- * `RunAuthorizer` seam from the opaque auth; this passes that auth straight
- * through and never inspects it.
+ * is freshly minted or reused is decided by the `RunAuthorizer` seam from the
+ * opaque auth; this passes that auth straight through and never inspects it.
  */
-export declare function authorizeDataProfile(deps: DataProfileTriggerDeps, params: DataProfileTriggerParams): ResultAsync<RunAuthorization, GateRefusal>;
+export declare function authorizeDataProfile(deps: DataProfileTriggerDeps, params: DataProfileTriggerParams): ResultAsync<RunSession, GateRefusal>;
 /**
  * Per-attempt DBOS workflow id. The `nonce` is fresh per attempt (a bare
  * `randomUUID()` minted at the trigger), so each (re-)profile of the same
@@ -261,3 +256,17 @@ export declare function triggerDataProfile(deps: DataProfileTriggerDeps, params:
  * can revoke it.
  */
 export declare function runDataProfile(deps: DataProfileTriggerDeps, params: DataProfileTriggerParams): ResultAsync<void, DataProfileStartError>;
+/** The ledger error of a profile that a stop ended. A client shows it, and a retry can follow it. */
+export declare const DATA_PROFILE_STOPPED = "Data profiling was stopped";
+/** What the stop of a data profile reaches: the ledger pool, and the notice of a settled profile. */
+export type DataProfileStopDeps = {
+    readonly pool: Querier;
+    readonly logger?: Logger;
+    readonly notifyDataProfileSettled?: NotifyDataProfileSettled;
+};
+/**
+ * Stop the profile workflow of an analysis, and fail its row. The body passes a cancel through its failure path,
+ * thus the row, the rows of its pauses, and the settled notice converge here. The revoke of the mandate and the
+ * teardown of the sandbox stay in the body, which runs them on its way out. The `running` guard of the row write keeps a profile that settled first.
+ */
+export declare function stopDataProfile(deps: DataProfileStopDeps, analysisId: string, workflowId: string): Promise<void>;