@inflexa-ai/harness 0.46.0 → 0.47.0

package/dist/sandbox/reconciler.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The sandbox reconciler (sandbox-leases spec): the backstop of the lease workflows.
+ *
+ * A lease workflow removes its own machine at each normal end. The reconciler covers the ends that a lease workflow
+ * cannot see: an operator cancel of the lease workflow, a purge, and a consumer that ends while its lease workflow
+ * waits in a pause. Each 5 minutes it does three passes in one DBOS step:
+ *
+ * 1. Each managed machine whose lease workflow is terminal goes away. A machine whose owner does not resolve goes
+ *    away only when a liveness probe finds it dead.
+ * 2. Each lease row whose lease workflow is terminal or absent becomes `released`, thus its capacity frees.
+ * 3. Each lease workflow whose owner is terminal gets a cancel, and the next sweep removes its machine.
+ *
+ * The pure decision (`classifyManaged`) and the sweep (`reconcileOnce`) take their effects as parameters, thus a
+ * test drives them without a DBOS runtime.
+ */
+import type { Logger } from "../lib/logger.js";
+import type { Querier } from "../state/db.js";
+import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
+import type { SandboxClient } from "./client.js";
+import type { ManagedSandbox } from "./types.js";
+export type ReconcileDecision = "leave" | "remove" | "remove-if-dead";
+/**
+ * Decide the fate of a managed machine. A resolved owner status is authoritative in both directions: DBOS records
+ * the status of a lease workflow at its enqueue, before its machine exists. A missing status is authoritative for
+ * neither, thus past the grace the decision defers to a liveness probe.
+ */
+export declare function classifyManaged(sb: ManagedSandbox, status: {
+    status: string;
+} | null, nowMs: number, graceMs: number): ReconcileDecision;
+export type ReconcilerDeps = {
+    readonly pool: Querier;
+    readonly sandboxClient: Pick<SandboxClient, "listManagedSandboxes" | "teardownById" | "isAliveById" | "teardown">;
+    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    readonly getStatus: (workflowId: string) => Promise<{
+        status: string;
+    } | null>;
+    /** Cancel a lease workflow whose owner ended. */
+    readonly cancel: (workflowId: string) => Promise<void>;
+    /** Creation-time grace before an unattributable machine is even probed. */
+    readonly graceMs?: number;
+    /** Wall-clock ms; injected for tests. */
+    readonly nowMs?: () => number;
+    readonly logger?: Logger;
+};
+export type ReconcileSummary = {
+    readonly managedCount: number;
+    readonly removedCount: number;
+    readonly leftCount: number;
+    /** Machines past the grace whose owner did not resolve, but which are alive. A non-zero value is a reported leak. */
+    readonly liveUnattributed: number;
+    readonly leasesReleased: number;
+    readonly leasesCanceled: number;
+};
+/** One sweep. A failure on one machine or one lease is logged and skipped, and the next sweep tries again. */
+export declare function reconcileOnce(deps: ReconcilerDeps): Promise<ReconcileSummary>;
+export type RegisterReconcilerDeps = Omit<ReconcilerDeps, "getStatus" | "nowMs">;
+/** Register the scheduled reconciler: one unsharded workflow, whose whole sweep is one step. */
+export declare function registerSandboxReconciler(deps: RegisterReconcilerDeps): void;

package/dist/sandbox/reconciler.js

@@ -0,0 +1,153 @@
+/**
+ * The sandbox reconciler (sandbox-leases spec): the backstop of the lease workflows.
+ *
+ * A lease workflow removes its own machine at each normal end. The reconciler covers the ends that a lease workflow
+ * cannot see: an operator cancel of the lease workflow, a purge, and a consumer that ends while its lease workflow
+ * waits in a pause. Each 5 minutes it does three passes in one DBOS step:
+ *
+ * 1. Each managed machine whose lease workflow is terminal goes away. A machine whose owner does not resolve goes
+ *    away only when a liveness probe finds it dead.
+ * 2. Each lease row whose lease workflow is terminal or absent becomes `released`, thus its capacity frees.
+ * 3. Each lease workflow whose owner is terminal gets a cancel, and the next sweep removes its machine.
+ *
+ * The pure decision (`classifyManaged`) and the sweep (`reconcileOnce`) take their effects as parameters, thus a
+ * test drives them without a DBOS runtime.
+ */
+import { rm } from "node:fs/promises";
+import { DBOS } from "@dbos-inc/dbos-sdk";
+import { createNoopLogger } from "../lib/console-logger.js";
+import { recordMachineReplaced } from "../lib/metrics.js";
+import { untracedWorkflow } from "../lib/otel-spans.js";
+import { unwrapOrThrow } from "../lib/result.js";
+import { scheduleWorkflow } from "../runtime/dbos.js";
+import { openLeases, releaseLease } from "../state/sandbox-leases.js";
+import { tailWritePrefix } from "../workspace/paths.js";
+import { leaseRecordTail } from "./lease-names.js";
+const RECONCILER_CRON = "0 */5 * * * *";
+const RECONCILER_WORKFLOW = "sandbox-reconciler";
+const DEFAULT_GRACE_MS = 10 * 60_000;
+/** The statuses of a workflow that still runs. A machine or a lease of such a workflow stays. */
+const ACTIVE_WORKFLOW_STATUSES = new Set(["PENDING", "ENQUEUED", "RUNNING"]);
+/**
+ * Decide the fate of a managed machine. A resolved owner status is authoritative in both directions: DBOS records
+ * the status of a lease workflow at its enqueue, before its machine exists. A missing status is authoritative for
+ * neither, thus past the grace the decision defers to a liveness probe.
+ */
+export function classifyManaged(sb, status, nowMs, graceMs) {
+    if (status)
+        return ACTIVE_WORKFLOW_STATUSES.has(status.status) ? "leave" : "remove";
+    const ageMs = sb.createdAtMs == null ? Number.POSITIVE_INFINITY : nowMs - sb.createdAtMs;
+    return ageMs >= graceMs ? "remove-if-dead" : "leave";
+}
+async function sweepMachines(deps, logger, nowMs, graceMs) {
+    const managed = await deps.sandboxClient.listManagedSandboxes();
+    let removedCount = 0;
+    let leftCount = 0;
+    let liveUnattributed = 0;
+    for (const sb of managed) {
+        const status = sb.ownerWorkflowId ? await deps.getStatus(sb.ownerWorkflowId) : null;
+        const decision = classifyManaged(sb, status, nowMs, graceMs);
+        if (decision === "leave") {
+            leftCount++;
+            continue;
+        }
+        if (decision === "remove-if-dead") {
+            if (sb.ownerWorkflowId)
+                logger.warn("owner workflow id resolved to no workflow", { sandboxId: sb.sandboxId, ownerWorkflowId: sb.ownerWorkflowId });
+            let liveness;
+            try {
+                liveness = await deps.sandboxClient.isAliveById(sb.sandboxId);
+            }
+            catch (failure) {
+                // A probe that cannot answer is not a dead machine. The next sweep probes again.
+                logger.warn("liveness probe threw — leaving this machine", { sandboxId: sb.sandboxId, ...logger.errorFields(failure) });
+                leftCount++;
+                continue;
+            }
+            if (liveness.alive) {
+                logger.warn("machine has no resolvable owner but is still alive — left standing", {
+                    sandboxId: sb.sandboxId,
+                    ownerWorkflowId: sb.ownerWorkflowId,
+                });
+                leftCount++;
+                liveUnattributed++;
+                continue;
+            }
+        }
+        try {
+            await deps.sandboxClient.teardownById(sb.sandboxId);
+            recordMachineReplaced({ cause: "release" });
+            removedCount++;
+        }
+        catch (failure) {
+            logger.warn("removal failed — skipping this round", { sandboxId: sb.sandboxId, ...logger.errorFields(failure) });
+        }
+    }
+    return { managedCount: managed.length, removedCount, leftCount, liveUnattributed };
+}
+async function sweepLeases(deps, logger) {
+    let leasesReleased = 0;
+    let leasesCanceled = 0;
+    for (const lease of unwrapOrThrow(await openLeases(deps.pool))) {
+        const status = await deps.getStatus(lease.leaseWorkflowId);
+        const leaseActive = status !== null && ACTIVE_WORKFLOW_STATUSES.has(status.status);
+        if (!leaseActive) {
+            // A lease row with no workflow: its acquire stopped before the enqueue. The owner reruns its acquire when it
+            // still runs, thus the row stays until the owner ends.
+            if (status === null) {
+                const owner = await deps.getStatus(lease.ownerWorkflowId);
+                if (owner !== null && ACTIVE_WORKFLOW_STATUSES.has(owner.status))
+                    continue;
+            }
+            try {
+                const released = unwrapOrThrow(await releaseLease(deps.pool, lease.leaseWorkflowId, "lease-workflow-ended"));
+                if (released?.machine !== undefined)
+                    await deps.sandboxClient.teardown(released.machine);
+                const dir = tailWritePrefix({ workspaceRoot: await deps.resolveWorkspaceRoot(lease.analysisId), tail: leaseRecordTail(lease.leaseKey) });
+                await rm(dir, { recursive: true, force: true });
+                leasesReleased++;
+            }
+            catch (failure) {
+                logger.warn("the release of an ended lease failed — skipping this round", {
+                    leaseWorkflowId: lease.leaseWorkflowId,
+                    ...logger.errorFields(failure),
+                });
+            }
+            continue;
+        }
+        const owner = await deps.getStatus(lease.ownerWorkflowId);
+        if (owner !== null && ACTIVE_WORKFLOW_STATUSES.has(owner.status))
+            continue;
+        try {
+            await deps.cancel(lease.leaseWorkflowId);
+            leasesCanceled++;
+        }
+        catch (failure) {
+            logger.warn("the cancel of a lease whose owner ended failed", { leaseWorkflowId: lease.leaseWorkflowId, ...logger.errorFields(failure) });
+        }
+    }
+    return { leasesReleased, leasesCanceled };
+}
+/** One sweep. A failure on one machine or one lease is logged and skipped, and the next sweep tries again. */
+export async function reconcileOnce(deps) {
+    const logger = (deps.logger ?? createNoopLogger()).named("sandbox-reconciler");
+    const nowMs = (deps.nowMs ?? (() => Date.now()))();
+    const graceMs = deps.graceMs ?? DEFAULT_GRACE_MS;
+    const machines = await sweepMachines(deps, logger, nowMs, graceMs);
+    const leases = await sweepLeases(deps, logger);
+    const summary = { ...machines, ...leases };
+    logger.info("sweep completed", { ...summary });
+    return summary;
+}
+/** Register the scheduled reconciler: one unsharded workflow, whose whole sweep is one step. */
+export function registerSandboxReconciler(deps) {
+    const reconciler = DBOS.registerWorkflow(async () => {
+        // One step for the whole sweep: the machine list is live cluster state, and it sets how many status reads
+        // run. In the body each status read takes a function id, thus a different list on a replay would diverge.
+        await DBOS.runStep(() => reconcileOnce({ ...deps, getStatus: async (workflowId) => await DBOS.getWorkflowStatus(workflowId) }), {
+            name: "sandbox-reconciler-sweep",
+        });
+    }, { name: RECONCILER_WORKFLOW });
+    untracedWorkflow(RECONCILER_WORKFLOW);
+    scheduleWorkflow({ scheduleName: RECONCILER_WORKFLOW, workflowFn: reconciler, schedule: RECONCILER_CRON });
+}

package/dist/sandbox/sandbox-step-translate.d.ts

@@ -41,7 +41,7 @@ export declare function toolActivityKey(toolUseId: string): string;
  * phase, and the `data-activity-entry` that keeps the report in the run stream under the synthesis step. `seq` is the
  * position of the report in the synthesis, so each entry has its own id. The `extra` fields stay on the progress part.
  */
-export declare function synthesisEmission(runId: string, stepId: string, seq: number, phase: SynthesisPhase, activity: string, at: string, extra: Pick<SynthesisProgressPart, "delegationCount" | "reason" | "error">): {
+export declare function synthesisEmission(runId: string, stepId: string, seq: number, phase: SynthesisPhase, activity: string, at: string, extra: Pick<SynthesisProgressPart, "reason" | "error">): {
     readonly progress: SynthesisProgressPart;
     readonly entry: ActivityEntryPart;
 };

package/dist/sandbox/types.d.ts

@@ -1,9 +1,9 @@
 /**
  * Sandbox-client types — the wire/persistence shapes that cross the
- * submit/poll protocol (see the harness-sandbox-exec spec) and the active-sandbox registry.
+ * submit/poll protocol (see the harness-sandbox-exec spec) and the lease table.
  *
- * `SandboxRef` is the handle the harness uses to talk to a live sandbox. The
- * active-sandbox registry persists the same shape (`PersistedSandboxRef`, from
+ * `SandboxRef` is the handle the harness uses to talk to a live sandbox. A lease
+ * row persists the same shape (`PersistedSandboxRef`, from
  * `harness/state/schema.ts`).
  */
 import type { ResultAsync } from "neverthrow";
@@ -212,6 +212,10 @@ export declare const ExecResultSchema: z.ZodObject<{
     stderrTotalBytes: z.ZodOptional<z.ZodNumber>;
     syntheticFailure: z.ZodOptional<z.ZodObject<{
         reason: z.ZodString;
+        memoryLimitGb: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    lost: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
     }, z.core.$strip>>;
     provenance: z.ZodOptional<z.ZodObject<{
         disabled: z.ZodDefault<z.ZodBoolean>;
@@ -276,6 +280,10 @@ export declare const PollResponseSchema: z.ZodObject<{
         stderrTotalBytes: z.ZodOptional<z.ZodNumber>;
         syntheticFailure: z.ZodOptional<z.ZodObject<{
             reason: z.ZodString;
+            memoryLimitGb: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        lost: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
         }, z.core.$strip>>;
         provenance: z.ZodOptional<z.ZodObject<{
             disabled: z.ZodDefault<z.ZodBoolean>;
@@ -327,10 +335,12 @@ export type SubmitExecBody = {
 };
 /** What a spawn needs beside its session. */
 export type SandboxSpec = {
-    /** Owning DBOS child workflow id (`"${parentRunId}-${N}"`). Recorded verbatim
-     *  on the sandbox machine under `cortex/owner-workflow-id` so the reaper can
-     *  map a cluster-side machine back to its workflow and check liveness. */
-    childWorkflowId: string;
+    /** The id of the lease workflow that owns the machine. Recorded verbatim on the
+     *  machine under `cortex/owner-workflow-id`, thus the reconciler maps a machine
+     *  back to its lease workflow. */
+    ownerWorkflowId: string;
+    /** The workspace-relative directory of the exec records of the lease. */
+    recordTail: string;
     /** Backend-specific extras carried through to the per-backend impl. */
     image?: string;
     extraEnv?: Record<string, string>;
@@ -356,23 +366,20 @@ export type SandboxLabels = Readonly<Record<string, string>>;
  */
 export type ResolveSandboxLabels = (session: RunSession) => ResultAsync<SandboxLabels, GateFailure>;
 /**
- * The identity minted for a sandbox machine *before* it is spawned — the
- * durable half of the two-step create (see the harness-sandbox-exec spec). Step 1 checkpoints this so a
- * recovery re-run of the spawn step adopts the already-created machine under
- * the same name instead of leaking a second one.
+ * The name of a sandbox machine. It comes from the lease workflow and the machine
+ * generation, thus a rerun of the spawn step adopts the machine of the earlier
+ * attempt instead of a second one.
  */
 export type SandboxIdentity = {
-    /** `sbx-{run8}-{uuid4}` — informative for `kubectl`, not load-bearing; the
-     *  checkpoint, not the name, is what makes create idempotent. */
+    /** `sbx-{run8}-{hash12}`. */
     sandboxId: string;
 };
 /**
  * A sandbox machine the backend is running that Cortex *manages*
- * (`app.kubernetes.io/managed-by=cortex`), enumerated by the reaper for the
- * cluster→registry sweep (see the harness-sandbox-exec spec). `ownerWorkflowId`
- * is the id as minted, so it is usable as a DBOS lookup key; null means the
- * machine records no owner, and such a machine is reaped only past a
- * creation-time grace and only when observably dead.
+ * (`app.kubernetes.io/managed-by=cortex`), enumerated by the reconciler.
+ * `ownerWorkflowId` is the id of the lease workflow as given, so it is usable as
+ * a DBOS lookup key; null means the machine records no owner, and such a machine
+ * is removed only past a creation-time grace and only when observably dead.
  */
 export type ManagedSandbox = {
     sandboxId: string;

package/dist/sandbox/types.js

@@ -1,9 +1,9 @@
 /**
  * Sandbox-client types — the wire/persistence shapes that cross the
- * submit/poll protocol (see the harness-sandbox-exec spec) and the active-sandbox registry.
+ * submit/poll protocol (see the harness-sandbox-exec spec) and the lease table.
  *
- * `SandboxRef` is the handle the harness uses to talk to a live sandbox. The
- * active-sandbox registry persists the same shape (`PersistedSandboxRef`, from
+ * `SandboxRef` is the handle the harness uses to talk to a live sandbox. A lease
+ * row persists the same shape (`PersistedSandboxRef`, from
  * `harness/state/schema.ts`).
  */
 import { z } from "zod";
@@ -78,12 +78,18 @@ export const ExecResultSchema = z.object({
     stderrTruncated: z.boolean().optional(),
     stdoutTotalBytes: z.number().int().nonnegative().optional(),
     stderrTotalBytes: z.number().int().nonnegative().optional(),
-    /** Set when the liveness probe found the machine dead under the exec. */
+    /**
+     * Set when the machine died under the exec, or when a new machine of the lease found the exec lost. The sandbox
+     * module adds the memory limit of the grant, thus the agent can tell its own memory use from an outside cause.
+     */
     syntheticFailure: z
         .object({
         reason: z.string(),
+        memoryLimitGb: z.number().optional(),
     })
         .optional(),
+    /** Set by sandbox-server on the record of an exec that a restart of the machine cut. */
+    lost: z.object({ reason: z.string() }).optional(),
     /** Runtime file-I/O frame from sandbox-server. Absent from a synthetic failure. */
     provenance: ProvenanceFrameSchema.optional(),
     /**

package/dist/schemas/plan-schemas.d.ts

@@ -18,13 +18,6 @@ export declare const PlanStepSchema: z.ZodObject<{
     caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
     packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     depends_on: z.ZodArray<z.ZodString>;
-    resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
-        cpu: z.ZodNumber;
-        memoryGb: z.ZodNumber;
-        gpu: z.ZodOptional<z.ZodObject<{
-            count: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
     grounding: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             flagged: "flagged";
@@ -69,13 +62,6 @@ export declare const PlannerPlanSchema: z.ZodObject<{
         caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
         packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         depends_on: z.ZodArray<z.ZodString>;
-        resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
-            cpu: z.ZodNumber;
-            memoryGb: z.ZodNumber;
-            gpu: z.ZodOptional<z.ZodObject<{
-                count: z.ZodNumber;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>>;
         grounding: z.ZodOptional<z.ZodObject<{
             status: z.ZodEnum<{
                 flagged: "flagged";
@@ -129,13 +115,6 @@ export declare const PlanningAgentOutputSchema: z.ZodObject<{
             caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
             packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             depends_on: z.ZodArray<z.ZodString>;
-            resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
-                cpu: z.ZodNumber;
-                memoryGb: z.ZodNumber;
-                gpu: z.ZodOptional<z.ZodObject<{
-                    count: z.ZodNumber;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>>;
             grounding: z.ZodOptional<z.ZodObject<{
                 status: z.ZodEnum<{
                     flagged: "flagged";

package/dist/schemas/plan-schemas.js

@@ -11,19 +11,18 @@ import { DEFAULT_SANDBOX_MAX_STEPS } from "../config/resource-limits.js";
  *  and the hardcoded sandbox turn budget. */
 export const PlanStepSchema = AnalysisStepSchema.omit({
     status: true,
-    timeout: true,
     summary: true,
     artifactIds: true,
     error: true,
     maxSteps: true,
 })
-    .required({ agent: true, resources: true, packages: true, capability: true })
+    .required({ agent: true, packages: true, capability: true })
     .extend({
     agent: z.enum(plannableAgentIds).describe("Sandbox agent ID, routed by the step's primary data object. Must be one of the available agents."),
 });
 /** Plan schema for planner output — uses PlanStepSchema for steps and requires
  *  a concise title (optional on the persistence schema for historical plans). */
-export const PlannerPlanSchema = AnalysisPlanSchema.extend({
+export const PlannerPlanSchema = AnalysisPlanSchema.omit({ request: true }).extend({
     title: z
         .string()
         .min(1)

package/dist/schemas/run-synthesis.d.ts

@@ -2,8 +2,8 @@
  * Run synthesis schema — cross-step findings grounded in literature.
  *
  * Produced by the synthesis step after all sandbox steps complete.
- * Combines computational findings from step summaries with literature
- * evidence from the literature-reviewer agent.
+ * Combines computational findings from step summaries with the literature
+ * evidence of the lookups of the synthesizer.
  *
  * This schema is the synthesizer's output contract: it is emitted as the
  * `submit_synthesis` tool's arg schema, so every field's meaning must live in

package/dist/schemas/run-synthesis.js

@@ -2,8 +2,8 @@
  * Run synthesis schema — cross-step findings grounded in literature.
  *
  * Produced by the synthesis step after all sandbox steps complete.
- * Combines computational findings from step summaries with literature
- * evidence from the literature-reviewer agent.
+ * Combines computational findings from step summaries with the literature
+ * evidence of the lookups of the synthesizer.
  *
  * This schema is the synthesizer's output contract: it is emitted as the
  * `submit_synthesis` tool's arg schema, so every field's meaning must live in
@@ -11,7 +11,7 @@
  */
 import { z } from "zod";
 export const LiteratureReferenceSchema = z.object({
-    pmid: z.string().describe("Numeric PubMed ID. Must come from a literature_reviewer response — never invented."),
+    pmid: z.string().describe("Numeric PubMed ID, from a lookup result of this run."),
     citation: z.string().describe('Short citation for the paper, e.g. "Smith 2020".'),
     relevance: z.string().describe("Why this paper matters to the finding — what it establishes, challenges, or contextualizes."),
     concordance: z

package/dist/schemas/validate-plan.d.ts

@@ -9,25 +9,12 @@
  * 1. Topological sort succeeds (no cycles, no missing deps)
  * 2. Output prefix uniqueness
  * 3. All agent assignments exist in the agent catalog
- * 4. All steps have resources defined
  */
-import type { ResourceLimits } from "../config/resource-limits.js";
 import type { AnalysisPlan } from "./workflow-state.js";
 export type ValidationResult = {
     valid: boolean;
     errors: string[];
 };
-export type ValidatePlanOptions = {
-    /**
-     * Host per-step resource ceilings. When present, a step whose declared
-     * `resources` exceed them is an error — the planner gets actionable
-     * feedback at plan time instead of a silent clamp at sandbox creation.
-     * The plan-generation path passes this; `execute_analysis` plan mode deliberately does
-     * not, so stored plans that predate the policy keep running (the
-     * sandbox-creation clamp remains their backstop).
-     */
-    readonly perStepCeiling?: ResourceLimits;
-};
 /** Derive a filesystem-safe output prefix from a step ID. */
 export declare function deriveOutputPrefix(stepId: string): string;
 /**
@@ -36,4 +23,4 @@ export declare function deriveOutputPrefix(stepId: string): string;
  * Returns `valid: true` if the plan passes all checks, or `valid: false`
  * with a list of human-readable error strings.
  */
-export declare function validatePlan(plan: AnalysisPlan, options?: ValidatePlanOptions): ValidationResult;
+export declare function validatePlan(plan: AnalysisPlan): ValidationResult;

package/dist/schemas/validate-plan.js

@@ -9,7 +9,6 @@
  * 1. Topological sort succeeds (no cycles, no missing deps)
  * 2. Output prefix uniqueness
  * 3. All agent assignments exist in the agent catalog
- * 4. All steps have resources defined
  */
 import { errorMessageOf } from "../lib/thrown.js";
 import { textOf } from "../lib/unknown-text.js";
@@ -75,7 +74,7 @@ export function deriveOutputPrefix(stepId) {
  * Returns `valid: true` if the plan passes all checks, or `valid: false`
  * with a list of human-readable error strings.
  */
-export function validatePlan(plan, options) {
+export function validatePlan(plan) {
     const errors = [];
     if (plan.steps.length === 0) {
         return { valid: true, errors: [] };
@@ -120,25 +119,7 @@ export function validatePlan(plan, options) {
             errors.push(`Step "${step.id}" assigns unknown agent "${step.agent}" — not found in agent catalog`);
         }
     }
-    // 4. Resources validation
-    const ceiling = options?.perStepCeiling;
-    for (const step of plan.steps) {
-        if (!step.resources) {
-            errors.push(`Step "${step.id}" has no resources defined — cpu and memoryGb are required`);
-            continue;
-        }
-        if (!ceiling)
-            continue;
-        if (step.resources.cpu > ceiling.maxCpu) {
-            errors.push(`Step "${step.id}" requests cpu: ${step.resources.cpu} but this host allows at most ` +
-                `${ceiling.maxCpu} per step — reduce cpu or restructure the step`);
-        }
-        if (step.resources.memoryGb > ceiling.maxMemoryGb) {
-            errors.push(`Step "${step.id}" requests memoryGb: ${step.resources.memoryGb} but this host allows at most ` +
-                `${ceiling.maxMemoryGb} per step — reduce memoryGb or restructure the step`);
-        }
-    }
-    // 5. Reserved step-id names (collide with artifact subdirectories or the
+    // 4. Reserved step-id names (collide with artifact subdirectories or the
     //    run-phase synthesis ledger row)
     for (const step of plan.steps) {
         if (RESERVED_STEP_IDS.has(step.id.toLowerCase())) {
@@ -147,7 +128,7 @@ export function validatePlan(plan, options) {
                 `step-directory convention; "${SYNTHESIS_STEP_ID}" is the run-level synthesis phase)`);
         }
     }
-    // 6. Each package entry is a query of the one grammar. The validation IS
+    // 5. Each package entry is a query of the one grammar. The validation IS
     //    the parse, thus no second reader of the grammar can disagree with the
     //    link pass. An absent array passes, because stored plans from before
     //    the field carry none.
@@ -158,7 +139,7 @@ export function validatePlan(plan, options) {
                 errors.push(describeParseError(step.id, entry, parsed.error));
         }
     }
-    // 7. Step-id path safety. The id becomes the `runs/{runId}/{stepId}` directory
+    // 6. Step-id path safety. The id becomes the `runs/{runId}/{stepId}` directory
     //    segment and a `/{analysisId}/…` container mount path; an unsafe segment
     //    (a slash, or `.`/`..`) could traverse or widen the mount. The sandbox
     //    mount boundary also rejects these (assertSafeId), but catching it here
@@ -170,7 +151,7 @@ export function validatePlan(plan, options) {
                 `and cannot be '.' or '..' (the id becomes a workspace directory and container mount segment)`);
         }
     }
-    // 8. Step-id label safety. The id also becomes the value of the sandbox
+    // 7. Step-id label safety. The id also becomes the value of the sandbox
     //    label `cortex/step-id`, and the harness stamps a label value with no
     //    change (sandbox-labels spec). A safe id can be too long for a label
     //    value, or it can start or end with a separator. Refused here, the

package/dist/schemas/workflow-state.d.ts

@@ -71,13 +71,6 @@ export declare const AnalysisStepSchema: z.ZodObject<{
         running: "running";
         skipped: "skipped";
     }>>;
-    resources: z.ZodOptional<z.ZodObject<{
-        cpu: z.ZodNumber;
-        memoryGb: z.ZodNumber;
-        gpu: z.ZodOptional<z.ZodObject<{
-            count: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
     grounding: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             flagged: "flagged";
@@ -97,7 +90,6 @@ export declare const AnalysisStepSchema: z.ZodObject<{
     }, z.core.$strip>>;
     agent: z.ZodOptional<z.ZodString>;
     capability: z.ZodOptional<z.ZodString>;
-    timeout: z.ZodOptional<z.ZodNumber>;
     maxSteps: z.ZodNumber;
     description: z.ZodOptional<z.ZodString>;
     summary: z.ZodOptional<z.ZodString>;
@@ -126,13 +118,6 @@ export declare const AnalysisPlanSchema: z.ZodObject<{
             running: "running";
             skipped: "skipped";
         }>>;
-        resources: z.ZodOptional<z.ZodObject<{
-            cpu: z.ZodNumber;
-            memoryGb: z.ZodNumber;
-            gpu: z.ZodOptional<z.ZodObject<{
-                count: z.ZodNumber;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
         grounding: z.ZodOptional<z.ZodObject<{
             status: z.ZodEnum<{
                 flagged: "flagged";
@@ -152,7 +137,6 @@ export declare const AnalysisPlanSchema: z.ZodObject<{
         }, z.core.$strip>>;
         agent: z.ZodOptional<z.ZodString>;
         capability: z.ZodOptional<z.ZodString>;
-        timeout: z.ZodOptional<z.ZodNumber>;
         maxSteps: z.ZodNumber;
         description: z.ZodOptional<z.ZodString>;
         summary: z.ZodOptional<z.ZodString>;
@@ -162,6 +146,7 @@ export declare const AnalysisPlanSchema: z.ZodObject<{
     created_at: z.ZodString;
     omicsType: z.ZodOptional<z.ZodString>;
     omicsSubtype: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Declarative suspension format — tells the frontend what to render
@@ -216,13 +201,6 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 running: "running";
                 skipped: "skipped";
             }>>;
-            resources: z.ZodOptional<z.ZodObject<{
-                cpu: z.ZodNumber;
-                memoryGb: z.ZodNumber;
-                gpu: z.ZodOptional<z.ZodObject<{
-                    count: z.ZodNumber;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
             grounding: z.ZodOptional<z.ZodObject<{
                 status: z.ZodEnum<{
                     flagged: "flagged";
@@ -242,7 +220,6 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }, z.core.$strip>>;
             agent: z.ZodOptional<z.ZodString>;
             capability: z.ZodOptional<z.ZodString>;
-            timeout: z.ZodOptional<z.ZodNumber>;
             maxSteps: z.ZodNumber;
             description: z.ZodOptional<z.ZodString>;
             summary: z.ZodOptional<z.ZodString>;
@@ -252,6 +229,7 @@ export declare const ContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         created_at: z.ZodString;
         omicsType: z.ZodOptional<z.ZodString>;
         omicsSubtype: z.ZodOptional<z.ZodString>;
+        request: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"json">;
@@ -354,13 +332,6 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
                     running: "running";
                     skipped: "skipped";
                 }>>;
-                resources: z.ZodOptional<z.ZodObject<{
-                    cpu: z.ZodNumber;
-                    memoryGb: z.ZodNumber;
-                    gpu: z.ZodOptional<z.ZodObject<{
-                        count: z.ZodNumber;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
                 grounding: z.ZodOptional<z.ZodObject<{
                     status: z.ZodEnum<{
                         flagged: "flagged";
@@ -380,7 +351,6 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
                 }, z.core.$strip>>;
                 agent: z.ZodOptional<z.ZodString>;
                 capability: z.ZodOptional<z.ZodString>;
-                timeout: z.ZodOptional<z.ZodNumber>;
                 maxSteps: z.ZodNumber;
                 description: z.ZodOptional<z.ZodString>;
                 summary: z.ZodOptional<z.ZodString>;
@@ -390,6 +360,7 @@ export declare const SuspensionPayloadSchema: z.ZodObject<{
             created_at: z.ZodString;
             omicsType: z.ZodOptional<z.ZodString>;
             omicsSubtype: z.ZodOptional<z.ZodString>;
+            request: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"json">;