@humwick/server 0.130.1 → 0.130.2

package/node_modules/@humwick/kernel/workflow-transitions.ts

@@ -1,317 +0,0 @@
-import { enterActivation, settleActivation, valueContext } from "./workflow-composition";
-import { expandItems } from "./workflow-container";
-import { validateWorkflowValue, workflowValue, workflowCondition, WorkflowValueError } from "./workflow-values";
-import { z } from "zod";
-import { type ModuleCtx, type StepResult } from "./contract";
-import { workflowBackstop, workflowStepChange } from "./workflow-backstop";
-import { workflowScriptResultSchema } from "./workflow-script";
-import { CI_MAIN_STEP, isLoopBack, routeOutcome, stepOutcome, stepReap, waitTimeoutMs, WORKFLOW_EXITED_OUTCOME, workflowStepPin, type RouteDecision } from "./workflow-definition";
-import { stores, requireRun, writeEffect, SIGNAL_TOPIC, ciVerdictSchema, type WorkflowRunRecord, type Awaiting } from "./workflow-state";
-export type RunState = { runId: string };
-type RunStep = StepResult<RunState>;
-
-function routeChange(run: WorkflowRunRecord, decision: RouteDecision, now: number) {
-  return { ...workflowStepChange(run, decision.target, now), counters: decision.counters, round: isLoopBack(run.definition, run.step, decision.target) ? run.round + 1 : run.round };
-}
-
-export function landIntent(run: WorkflowRunRecord, override = run.resuming !== undefined): Record<string, unknown> {
-  const resume = run.resumes?.at(-1);
-  const entry = run.rounds.at(-1)?.steps.at(-1);
-  const source = override ? { at: resume?.at, by: resume?.by, step: resume?.step, escalation: resume?.escalation }
-    : { at: entry?.at, taskId: entry?.taskId, step: entry?.step, outcome: entry?.outcome };
-  return { taskId: run.taskId, eventId: run.cursor, workspaceId: run.deliveryWorkspaceId, head: run.head,
-    approval: { kind: override ? "override" : "go", source } };
-}
-
-/** Enter `run.step`: write its effect and park until the src supervisor signals the wait. */
-export async function enter(ctx: ModuleCtx, state: RunState): Promise<RunStep> {
-  const run = await requireRun(ctx, state.runId);
-  if (run.cancel) return finish(ctx, run, {}, { status: "cancelled", reason: run.cancel.reason });
-  const seq = run.waitSeq + 1;
-  const key = `${run.id}:${seq}`;
-  const now = ctx.clock.now();
-  const resume = run.resuming ? { resume: run.resuming } : {};
-  // The dispatch carries the pin it applies, so a retried effect spawns what this entry decided.
-  const applied = workflowStepPin(run.definition, run.pins, run.step, run.routingDefaults);
-  const pin = applied ? { pin: applied } : {};
-  const declared = run.definition.steps[run.step];
-  try {
-    if (declared?.condition !== undefined && !workflowCondition(declared.condition, valueContext(run))) {
-      await enterActivation(ctx, run, key, now, true);
-      const current = await requireRun(ctx, run.id);
-      const patch = await settleActivation(ctx, current, "skipped", {});
-      const decision = routeOutcome(run.definition, run.step, "skipped", run.counters, valueContext({ ...current, ...patch }));
-      const update = { ...patch, waitSeq: seq, counters: decision.counters };
-      if (decision.target === "done") return finish(ctx, current, update, { status: "done" });
-      if (decision.target === "fail" || decision.target === "escalate") return finish(ctx, current, update, { status: decision.target === "fail" ? "failed" : "escalated", reason: "skipped step route" });
-      await stores(ctx).run.update(run.id, { ...update, ...routeChange(run, decision, now) });
-      return { state, next: "enter" };
-    }
-  } catch (error) { return finish(ctx, await requireRun(ctx, run.id), {}, { status: "failed", reason: String(error) }); }
-  const decisionWait = run.definition.steps[run.step]?.decision;
-  const activationDeadline = decisionWait ? (decisionWait.deadlineMs === undefined ? undefined : now + decisionWait.deadlineMs) : now + waitTimeoutMs(run.definition, run.step);
-  let data: Record<string, unknown> = {};
-  try { data = await enterActivation(ctx, run, key, activationDeadline); }
-  catch (error) { return finish(ctx, run, {}, { status: "escalated", reason: String(error) }); }
-  let awaiting: Awaiting;
-  let landOperationId: string | undefined;
-  if (run.step === "close") {
-    const id = await writeEffect(ctx, run, seq, "close", {}, key);
-    awaiting = { key, kind: "closed", effectId: id, afterEventId: run.cursor, since: now };
-  } else if (run.step === "land") {
-    landOperationId = await writeEffect(ctx, run, seq, "clear-hold", landIntent(run), key);
-    awaiting = { key, kind: "landed", taskId: run.taskId, afterEventId: run.cursor, since: now };
-  } else if (run.step === CI_MAIN_STEP) {
-    // The work landed: no step agent has anything left to do while CI runs.
-    await writeEffect(ctx, run, seq, "reap", { scope: "run" });
-    awaiting = { key, kind: "ci", taskId: run.taskId, sha: run.landed!.sha, afterEventId: run.cursor, since: now };
-  } else {
-    const step = run.definition.steps[run.step]!;
-    if (step.forEach) {
-      try { await expandItems(ctx, await requireRun(ctx, run.id)); }
-      catch (error) { return finish(ctx, await requireRun(ctx, run.id), {}, { status: "escalated", reason: String(error) }); }
-      awaiting = { key, kind: "for-each", afterEventId: 0, since: now };
-    } else if (step.decision) {
-      const id = await writeEffect(ctx, run, seq, "decision", { step: run.step, ...data }, key);
-      awaiting = { key, kind: "decision", effectId: id, afterEventId: 0, since: now, ...(step.decision.deadlineMs !== undefined ? { deadline: now + step.decision.deadlineMs } : {}) };
-    } else if (step.workflow) {
-      const id = await writeEffect(ctx, run, seq, "child", { step: run.step, ...data }, key);
-      awaiting = { key, kind: "child", effectId: id, afterEventId: 0, since: now };
-    } else if (step.script) {
-      const poll = run.scriptPoll ?? { step: run.step, attempt: 1, deadline: now + step.script.timeoutMs, nextAt: now };
-      const id = await writeEffect(ctx, run, seq, "script", { ...poll, ...data }, key);
-      awaiting = { key, kind: "script", effectId: id, afterEventId: run.cursor, since: now, deadline: poll.deadline };
-      await stores(ctx).run.update(run.id, { scriptPoll: poll });
-    } else if (step.task === "input") {
-      // #3660 — a gated input step (a single-agent audit) links its Task with the gate, so its delivery is a verdict.
-      const inputGate = step.gate ? { gate: step.gate } : {};
-      if (run.resuming) {
-        // The src effect hands the note to the warm builder, or dispatches a fresh one when it is gone.
-        await writeEffect(ctx, run, seq, "dispatch", { step: run.step, role: step.role, taskId: run.taskId, round: run.round, hold: true, ...inputGate, ...resume, ...pin, ...data }, key);
-      } else if (run.entered.includes(run.step)) {
-        await writeEffect(ctx, run, seq, "findings", { taskId: run.taskId, round: run.round, ...run.feedback }, key);
-      } else {
-        await writeEffect(ctx, run, seq, "dispatch", { step: run.step, role: step.role, taskId: run.taskId, hold: true, ...inputGate, ...pin, ...data }, key);
-      }
-      awaiting = { key, kind: "delivery", taskId: run.taskId, afterEventId: run.cursor, since: now };
-    } else {
-      const id = await writeEffect(ctx, run, seq, "dispatch", {
-        step: run.step, role: step.role, round: run.round, parentTaskId: run.taskId,
-        ...(run.head ? { head: run.head } : {}), ...(step.gate ? { gate: step.gate } : {}), ...resume, ...pin, ...data,
-      }, key);
-      awaiting = { key, kind: "delivery", effectId: id, afterEventId: 0, since: now };
-    }
-  }
-  if (awaiting.kind !== "decision") awaiting.deadline ??= now + waitTimeoutMs(run.definition, run.step);
-  const entered = run.step === "land" || run.entered.includes(run.step) ? run.entered : [...run.entered, run.step];
-  const backstop = run.scriptPoll && run.overdueAt !== undefined ? {} : workflowBackstop(run, now, awaiting.deadline);
-  await stores(ctx).run.update(run.id, { ...backstop, waitSeq: seq, awaiting, entered, resuming: undefined, ...(landOperationId ? { landOperationId } : {}), updatedAt: now });
-  return { state, next: "route", waitFor: { kind: "event", topic: SIGNAL_TOPIC, correlationId: key } };
-}
-
-type RunEnd = { status: "escalated" | "cancelled" | "failed"; reason: string } | { status: "done"; landedSha?: string; nothingToLand?: boolean; ci?: z.output<typeof ciVerdictSchema> };
-
-async function finish(ctx: ModuleCtx, run: WorkflowRunRecord, patch: Partial<WorkflowRunRecord>, end: RunEnd, cleanupSettled = false): Promise<RunStep> {
-  const now = ctx.clock.now();
-  const final = { ...run, ...patch, status: end.status, ...(end.status === "done" && end.landedSha ? { landed: { ...run.landed, sha: end.landedSha, at: run.landed?.at ?? now } } : {}) };
-  let returned: Record<string, unknown> | undefined;
-  if (end.status === "done" && run.definition.version === 2) {
-    try {
-      returned = (cleanupSettled ? run.finalizing : workflowValue(run.definition.returns ?? {}, valueContext(final))) as Record<string, unknown>;
-      validateWorkflowValue(run.definition.outputs, returned, "OUTPUT_INVALID");
-    } catch (error) { return finish(ctx, run, patch, { status: "failed", reason: String(error) }); }
-  }
-  // The end consumes its seq, so a resumed run's next step and end never reuse these effect ids.
-  const seq = run.waitSeq + 1;
-  if (run.awaiting?.kind === "decision") await writeEffect(ctx, run, seq, "withdraw-decision", { effectId: run.awaiting.effectId });
-  if (run.activationId) {
-    const activation = await stores(ctx).activation.get(run.activationId);
-    if (activation && activation.state === "waiting") await stores(ctx).activation.update(activation.id, { state: end.status === "done" ? "succeeded" : end.status === "cancelled" ? "cancelled" : "paused", outcome: end.status, updatedAt: now });
-  }
-  if (end.status === "done" && !cleanupSettled) {
-    const ci = end.ci ?? final.landed?.ci;
-    const output = (cleanupSettled ? run.finalizing : undefined) ?? returned ?? { landedSha: end.landedSha, rounds: final.round, ...(end.nothingToLand ? { nothingToLand: true } : {}), ...(ci ? { ci } : {}) };
-    const key = `${run.id}:${seq}`;
-    const id = await writeEffect(ctx, final, seq, "reap", { scope: "run" }, key);
-    await stores(ctx).run.update(run.id, { ...patch, waitSeq: seq, ...(final.landed ? { landed: final.landed } : {}), finalizing: output, cleanup: { status: "pending", deadline: now + 300000 }, awaiting: { kind: "cleanup", key, effectId: id, afterEventId: run.cursor, since: now, deadline: now + 300000 }, updatedAt: now });
-    return { state: { runId: run.id }, next: "route", waitFor: { kind: "event", topic: SIGNAL_TOPIC, correlationId: key } };
-  }
-  if (!cleanupSettled) await writeEffect(ctx, final, seq, "reap", { scope: "run" });
-  if (end.status !== "done") {
-    // A cancel is the coordinator's own act (cancel, abandon): nothing to tell it.
-    const escalation = end.status === "escalated" || end.status === "failed" ? { escalation: { id: await writeEffect(ctx, final, seq, "escalate", { reason: end.reason }), at: now } } : {};
-    await stores(ctx).run.update(run.id, { ...patch, ...escalation, ...(end.status === "cancelled" ? { cleanup: run.cleanup ?? { status: "pending" as const, deadline: now + 300000 } } : {}), waitSeq: seq, status: end.status, reason: end.reason, awaiting: null, resuming: undefined, updatedAt: now });
-  } else {
-    const ci = end.ci ?? final.landed?.ci;
-    const output = (cleanupSettled ? run.finalizing : undefined) ?? returned ?? { landedSha: end.landedSha, rounds: final.round, ...(end.nothingToLand || final.landed?.nothingToLand ? { nothingToLand: true } : {}), ...(ci ? { ci } : {}) };
-    await writeEffect(ctx, final, seq, "result", output);
-    await stores(ctx).run.update(run.id, { ...patch, waitSeq: seq, status: "done", finalizing: undefined, cleanup: { status: "complete", deadline: run.cleanup?.deadline ?? now }, output, ...(run.rootRunId ? { outputs: output } : {}), awaiting: null, resuming: undefined, updatedAt: now });
-  }
-  await ctx.events.emit("workflow.finished", { runId: run.id, status: end.status });
-  return { state: { runId: run.id }, next: "done", output: end };
-}
-
-function textField(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-
-/** Consume the signal of the current wait and decide the next step. */
-export async function route(ctx: ModuleCtx, state: RunState): Promise<RunStep> {
-  try { return await routeSignal(ctx, state); }
-  catch (error) {
-    if (!(error instanceof WorkflowValueError)) throw error;
-    return finish(ctx, await requireRun(ctx, state.runId), {}, { status: "failed", reason: error.message });
-  }
-}
-
-async function routeSignal(ctx: ModuleCtx, state: RunState): Promise<RunStep> {
-  const run = await requireRun(ctx, state.runId);
-  // A cancel wins over whatever woke the wait, including a result that arrived first.
-  if (run.cancel) return finish(ctx, run, {}, { status: "cancelled", reason: run.cancel.reason });
-  const key = run.awaiting?.key;
-  const signal = key ? await stores(ctx).signal.get(key) : undefined;
-  if (!signal) throw new Error(`workflow run '${run.id}' woke without the signal for its wait`);
-  // The resume op already set the run up; a run leaving its land wait takes its step now the Task is held.
-  if (signal.kind === "resume") {
-    const to = run.resuming?.to;
-    if (to) await stores(ctx).run.update(run.id, { ...workflowStepChange(run, to, ctx.clock.now()), resuming: run.resuming?.note ? { note: run.resuming.note } : {} });
-    return { state, next: "enter" };
-  }
-  const payload = signal.payload;
-  if (run.awaiting?.kind === "cleanup" && signal.kind === "cleanup") return finish(ctx, run, {}, { status: "done" }, true);
-  if (signal.kind === "effect-failed") {
-    const message = `${String(payload.effect)} failed: ${String(payload.error)}`;
-    const patch = await settleActivation(ctx, run, "blocked", {}, { code: String(payload.error).split(":")[0], message, effectId: run.awaiting?.effectId });
-    return finish(ctx, run, patch, { status: "escalated", reason: message });
-  }
-  if (signal.kind === "land-withdrawn") {
-    // #3603 — a withdrawn land parks the run at the step that delivered it: same run, builder and worktree.
-    const delivering = run.rounds.flatMap((round) => round.steps).reverse().find((entry) => entry.taskId === run.taskId && run.definition.steps[entry.step]?.task === "input")?.step;
-    if (!delivering) return finish(ctx, run, {}, { status: "cancelled", reason: String(payload.reason) });
-    const note = `The armed land of ${run.head ?? "your delivered head"} was withdrawn: ${String(payload.reason)}. The run is parked here; your worktree and commits are kept.`;
-    await stores(ctx).run.update(run.id, { ...workflowStepChange(run, delivering, ctx.clock.now()), round: run.round + 1, feedback: null, resuming: { note } });
-    return { state, next: "enter" };
-  }
-  if (signal.kind === "land-cancelled" || signal.kind === "start-refused") return finish(ctx, run, {}, { status: "cancelled", reason: String(payload.reason) });
-  if (run.step === "close") return finish(ctx, run, {}, { status: "done", landedSha: String(payload.landedSha ?? run.landed?.sha) });
-  if (run.step === CI_MAIN_STEP) {
-    const ci = ciVerdictSchema.parse(payload);
-    if (run.definition.land?.then) {
-      if (ci.status !== "pass") return finish(ctx, run, {}, { status: "escalated", reason: `CI on main: ${ci.status}; verification did not run` });
-      await stores(ctx).run.update(run.id, { ...workflowStepChange(run, run.definition.land.then, ctx.clock.now()), landed: { ...run.landed!, ci } });
-      return { state, next: "enter" };
-    }
-    return finish(ctx, run, {}, { status: "done", landedSha: run.landed!.sha, ci });
-  }
-  if (run.step === "land") {
-    if (run.definition.land?.then) {
-      const landed = { sha: String(payload.sha), at: ctx.clock.now(), ...(payload.nothingToLand === true ? { nothingToLand: true } : {}) };
-      const next = run.definition.ciMain && !landed.nothingToLand ? CI_MAIN_STEP : run.definition.land.then;
-      await stores(ctx).run.update(run.id, { ...workflowStepChange(run, next, ctx.clock.now()), landed });
-      return { state, next: "enter" };
-    }
-    // Nothing landed, so CI on main has no land of this run's to judge.
-    if (payload.nothingToLand === true) return finish(ctx, run, {}, { status: "done", landedSha: String(payload.sha), nothingToLand: true });
-    if (!run.definition.ciMain) return finish(ctx, run, {}, { status: "done", landedSha: String(payload.sha) });
-    await stores(ctx).run.update(run.id, { ...workflowStepChange(run, CI_MAIN_STEP, ctx.clock.now()), landed: { sha: String(payload.sha), at: ctx.clock.now() } });
-    return { state, next: "enter" };
-  }
-
-  const step = run.definition.steps[run.step]!;
-  if (step.decision || step.workflow || step.forEach) {
-    const outputs = (payload.outputs ?? {}) as Record<string, unknown>;
-    const outcome = String(payload.outcome);
-    let patch: Partial<WorkflowRunRecord>;
-    try {
-      if (outcome === "complete" && step.outputSchema) validateWorkflowValue(step.outputSchema, outputs, "OUTPUT_INVALID");
-      patch = await settleActivation(ctx, run, outcome, outputs, payload.error as Record<string, unknown> | undefined);
-    } catch (error) {
-      patch = await settleActivation(ctx, run, "failed", {}, { code: "OUTPUT_INVALID", message: String(error), childRunId: payload.childRunId });
-      return finish(ctx, run, patch, { status: "failed", reason: String(error) });
-    }
-    const decision = routeOutcome(run.definition, run.step, outcome, run.counters, valueContext({ ...run, ...patch }));
-    patch.counters = decision.counters;
-    if (decision.target === "done") return finish(ctx, run, patch, { status: "done" });
-    if (decision.target === "fail" || decision.target === "escalate") return finish(ctx, run, patch, { status: decision.target === "fail" ? "failed" : "escalated", reason: String(payload.error ?? decision.reason ?? `child ${outcome}`) });
-    await stores(ctx).run.update(run.id, { ...patch, ...routeChange(run, decision, ctx.clock.now()) });
-    return { state, next: "enter" };
-  }
-  if (step.script) {
-    const result = workflowScriptResultSchema.parse(payload);
-    const outcome = result.timedOut ? "timeout" : String(result.exitCode ?? "unknown");
-    const decision = routeOutcome(run.definition, run.step, outcome, run.counters, valueContext({ ...run, results: { ...run.results, [run.step]: { status: result.exitCode === 0 ? "succeeded" : "failed", outputs: result.output ?? {} } } }));
-    await stores(ctx).scriptAttempt.create({ id: signal.id, runId: run.id, ...result });
-    const scriptOutputs = { ...run.scriptOutputs, ...(result.output ? { [run.step]: result.output } : {}) };
-    if (decision.target === "wait") {
-      await stores(ctx).run.update(run.id, { scriptOutputs, scriptPoll: { ...run.scriptPoll!, attempt: result.attempt + 1, nextAt: ctx.clock.now() + step.script.everyMs! }, updatedAt: ctx.clock.now() });
-      return { state, next: "enter" };
-    }
-    const entry = { step: run.step, taskId: run.taskId, outcome, startedAt: run.awaiting!.since, at: ctx.clock.now() };
-    const rounds = run.rounds.some((r) => r.round === run.round)
-      ? run.rounds.map((r) => r.round === run.round ? { ...r, steps: [...r.steps, entry] } : r)
-      : [...run.rounds, { round: run.round, steps: [entry] }];
-    let activationPatch: Partial<WorkflowRunRecord> = {};
-    if (run.rootRunId) {
-      try {
-        if (result.error) throw new Error(String(result.error.message));
-        if (step.outputSchema) validateWorkflowValue(step.outputSchema, result.output ?? {}, "OUTPUT_INVALID");
-        activationPatch = await settleActivation(ctx, run, decision.outcome ?? (decision.target === "escalate" ? "blocked" : decision.target === "fail" ? "failed" : "complete"), result.output ?? {});
-      } catch (error) {
-        activationPatch = await settleActivation(ctx, run, "failed", {}, { code: "OUTPUT_INVALID", message: String(error), artifactId: result.logArtifactId });
-        return finish(ctx, run, { ...activationPatch, scriptPoll: undefined, rounds }, { status: "failed", reason: `OUTPUT_INVALID: ${String(error)}` });
-      }
-    }
-    const patch = { scriptOutputs, scriptPoll: undefined, rounds, ...activationPatch, counters: decision.counters };
-    if (decision.target === "escalate" || decision.target === "fail") return finish(ctx, run, patch, { status: decision.target === "fail" ? "failed" : "escalated", reason: decision.reason! });
-    if (decision.target === "done") return finish(ctx, run, patch, { status: "done", landedSha: run.landed?.sha ?? "" });
-    await stores(ctx).run.update(run.id, { ...patch, ...routeChange(run, decision, ctx.clock.now()) });
-    return { state, next: "enter" };
-  }
-  const exited = signal.kind === "agent-exited";
-  const outcome = exited ? WORKFLOW_EXITED_OUTCOME : stepOutcome(step, { disposition: String(payload.disposition), gateStatus: textField(payload.gateStatus) });
-  const input = step.task === "input";
-  const head = input ? textField(payload.head) ?? run.head : run.head;
-  const entry = {
-    step: run.step,
-    taskId: Number(payload.taskId),
-    outcome,
-    ...(head ? { head } : {}),
-    ...(textField(payload.summary) ? { summary: textField(payload.summary) } : {}),
-    ...(textField(payload.findings) ? { findings: textField(payload.findings) } : {}),
-    ...(run.awaiting ? { startedAt: run.awaiting.since } : {}),
-    at: ctx.clock.now(),
-  };
-  const rounds = run.rounds.some((r) => r.round === run.round)
-    ? run.rounds.map((r) => (r.round === run.round ? { ...r, steps: [...r.steps, entry] } : r))
-    : [...run.rounds, { round: run.round, steps: [entry] }];
-  if (stepReap(step) === "on-step-done") await writeEffect(ctx, run, run.waitSeq, "reap", { scope: "step", step: run.step });
-  const decision = routeOutcome(run.definition, run.step, outcome, run.counters, valueContext({ ...run, results: { ...run.results, [run.step]: { status: outcome === "complete" || outcome === "pass" ? "succeeded" : "failed", outcome, outputs: payload.outputs ?? {} } } }));
-  // An exit consumed no delivery, so the next wait still counts from the last one.
-  let activationPatch: Partial<WorkflowRunRecord> = {};
-  if (run.rootRunId) {
-    const outputs = payload.outputs as Record<string, unknown> | undefined ?? {};
-    try {
-      if (step.outputSchema) validateWorkflowValue(step.outputSchema, outputs, "OUTPUT_INVALID");
-      activationPatch = await settleActivation(ctx, run, outcome, outputs);
-    } catch (error) {
-      activationPatch = await settleActivation(ctx, run, "failed", {}, { code: "OUTPUT_INVALID", message: String(error), deliveryEventId: payload.eventId });
-      return finish(ctx, run, activationPatch, { status: "failed", reason: String(error) });
-    }
-  }
-  const patch: Partial<WorkflowRunRecord> = { ...activationPatch, rounds, counters: decision.counters, scriptOutputs: { ...run.scriptOutputs, [run.step]: payload }, ...(input && !exited ? { cursor: Number(payload.eventId), deliveryWorkspaceId: textField(payload.workspaceId) } : {}), ...(head ? { head } : {}) };
-  await ctx.events.emit("workflow.routed", { runId: run.id, step: run.step, outcome, target: decision.target });
-  if (decision.target === "done") return finish(ctx, run, patch, { status: "done" });
-  if (decision.target === "fail") return finish(ctx, run, patch, { status: "failed", reason: `step ${run.step} returned ${outcome}` });
-  if (decision.target === "escalate") {
-    // An exit the workflow does not route escalates with its own account.
-    const reason = exited && !run.definition.routes[run.step]?.[outcome] ? String(payload.summary) : decision.reason ?? `step ${run.step} returned ${outcome}`;
-    return finish(ctx, run, patch, { status: "escalated", reason });
-  }
-
-  const loop = isLoopBack(run.definition, run.step, decision.target);
-  const feedback = loop && run.definition.steps[decision.target]?.task === "input"
-    ? { ...(head ? { head } : {}), findings: entry.findings ?? entry.summary ?? outcome, taskId: entry.taskId, step: run.step }
-    : null;
-  await stores(ctx).run.update(run.id, { ...patch, ...routeChange(run, decision, ctx.clock.now()), feedback });
-  return { state, next: "enter" };
-}

package/node_modules/@humwick/kernel/workflow-values.ts

@@ -1,153 +0,0 @@
-import jsep from "jsep";
-import Ajv, { type ValidateFunction } from "ajv";
-import { z } from "zod";
-
-export const workflowObject = z.record(z.string(), z.unknown());
-export const emptyBoundary = { type: "object", additionalProperties: false, properties: {} };
-const ajv = new Ajv({ strict: true, allErrors: true, coerceTypes: false, useDefaults: false, removeAdditional: false });
-const compiled = new Map<string, ValidateFunction>();
-function schemaKey(schema: Record<string, unknown>): string { return JSON.stringify(schema); }
-const keywords = new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "const", "nullable", "minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "minLength", "maxLength", "minItems", "maxItems", "uniqueItems", "minProperties", "maxProperties", "$defs", "$ref", "description", "title"]);
-
-export class WorkflowValueError extends Error {
-  constructor(readonly code: string, message: string) { super(`${code}: ${message}`); }
-}
-
-export function validateWorkflowSchema(schema: Record<string, unknown>, boundary = false): void {
-  if (boundary && (schema.type !== "object" || schema.additionalProperties !== false)) throw new WorkflowValueError("SCHEMA_INVALID", "boundary must declare type: object and additionalProperties: false");
-  let nodes = 0;
-  function visit(value: unknown, depth: number): void {
-    if (++nodes > 1000 || depth > 32) throw new WorkflowValueError("SCHEMA_INVALID", "schema exceeds depth/node limit");
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new WorkflowValueError("SCHEMA_INVALID", "schema must be an object");
-    for (const [key, child] of Object.entries(value)) {
-      if (!keywords.has(key)) throw new WorkflowValueError("SCHEMA_INVALID", `unsupported keyword ${key}`);
-      if (key === "$ref" && (typeof child !== "string" || !child.startsWith("#/$defs/"))) throw new WorkflowValueError("SCHEMA_INVALID", "only local $defs references are supported");
-      if (key === "properties" || key === "$defs") {
-        if (!child || typeof child !== "object" || Array.isArray(child)) throw new WorkflowValueError("SCHEMA_INVALID", `${key} must be an object`);
-        for (const nested of Object.values(child)) visit(nested, depth + 1);
-      } else if (key === "items" || (key === "additionalProperties" && typeof child === "object")) visit(child, depth + 1);
-    }
-  }
-  visit(schema, 0);
-  const key = schemaKey(schema);
-  if (!compiled.has(key)) {
-    if (compiled.size >= 512) compiled.delete(compiled.keys().next().value!);
-    compiled.set(key, ajv.compile(schema));
-  }
-}
-
-export function validateWorkflowValue(schema: Record<string, unknown> | undefined, data: Record<string, unknown>, code: string): void {
-  if (new TextEncoder().encode(JSON.stringify(data)).length > 65536) throw new WorkflowValueError(code, "object exceeds 64 KiB");
-  const definition = schema ?? emptyBoundary;
-  if (!compiled.has(schemaKey(definition))) validateWorkflowSchema(definition);
-  const check = compiled.get(schemaKey(definition))!;
-  if (!check(data)) throw new WorkflowValueError(code, ajv.errorsText(check.errors));
-}
-
-const expressions = new Map<string, jsep.Expression>();
-const binary = ["&&", "||", "==", "!=", "<", "<=", ">", ">="];
-class MissingPath extends WorkflowValueError {}
-function children(node: jsep.Expression): jsep.Expression[] {
-  if (node.type === "MemberExpression") return [(node as jsep.MemberExpression).object];
-  if (node.type === "UnaryExpression") return [(node as jsep.UnaryExpression).argument];
-  if (node.type === "BinaryExpression") return [(node as jsep.BinaryExpression).left, (node as jsep.BinaryExpression).right];
-  if (node.type === "CallExpression") return (node as jsep.CallExpression).arguments;
-  return [];
-}
-function expression(text: string): jsep.Expression {
-  const source = /^\$\{\{([\s\S]*)\}\}$/.exec(text)?.[1];
-  if (source === undefined || source.length > 4096) throw new WorkflowValueError("EXPRESSION_INVALID", "expected a whole expression");
-  const cached = expressions.get(source);
-  if (cached) return cached;
-  let parsed: jsep.Expression;
-  try { parsed = jsep(source); } catch (error) { throw new WorkflowValueError("EXPRESSION_INVALID", String(error)); }
-  let nodes = 0;
-  function check(node: jsep.Expression, depth: number): void {
-    if (++nodes > 256 || depth > 32) throw new WorkflowValueError("EXPRESSION_INVALID", "expression exceeds depth/node limit");
-    let valid = false;
-    if (node.type === "Identifier") valid = ["inputs", "steps", "run", "item", "index"].includes((node as jsep.Identifier).name);
-    if (node.type === "Literal") valid = (node as jsep.Literal).value === null || ["string", "boolean", "number"].includes(typeof (node as jsep.Literal).value);
-    if (node.type === "MemberExpression") {
-      const member = node as jsep.MemberExpression;
-      const property = member.computed ? (member.property as jsep.Literal).value : (member.property as jsep.Identifier).name;
-      valid = (!member.computed || member.property.type === "Literal") && (typeof property === "string" || typeof property === "number" && Number.isSafeInteger(property) && property >= 0) && !["__proto__", "prototype", "constructor"].includes(String(property));
-    }
-    if (node.type === "UnaryExpression") valid = (node as jsep.UnaryExpression).operator === "!" || (node as jsep.UnaryExpression).operator === "-" && (node as jsep.UnaryExpression).argument.type === "Literal" && typeof ((node as jsep.UnaryExpression).argument as jsep.Literal).value === "number";
-    if (node.type === "BinaryExpression") valid = binary.includes((node as jsep.BinaryExpression).operator);
-    if (node.type === "CallExpression") {
-      const call = node as jsep.CallExpression;
-      valid = call.callee.type === "Identifier" && (call.callee as jsep.Identifier).name === "has" && call.arguments.length === 1 && ["MemberExpression", "Identifier"].includes(call.arguments[0]!.type);
-    }
-    if (!valid) throw new WorkflowValueError("EXPRESSION_INVALID", `unsupported ${node.type}`);
-    for (const child of children(node)) check(child, depth + 1);
-  }
-  check(parsed, 0);
-  if (expressions.size >= 1024) expressions.delete(expressions.keys().next().value!);
-  expressions.set(source, parsed);
-  return parsed;
-}
-
-export function validateWorkflowExpressions(value: unknown, steps: readonly string[]): void {
-  if (typeof value === "string" && value.startsWith("${{")) {
-    function names(part: jsep.Expression): void {
-      if (part.type === "MemberExpression") {
-        const member = part as jsep.MemberExpression;
-        if (member.object.type === "Identifier" && (member.object as jsep.Identifier).name === "steps") {
-          const name = member.computed ? (member.property as jsep.Literal).value : (member.property as jsep.Identifier).name;
-          if (!steps.includes(String(name))) throw new WorkflowValueError("EXPRESSION_INVALID", `unknown step ${String(name)}`);
-        }
-      }
-      for (const child of children(part)) names(child);
-    }
-    names(expression(value));
-  } else if (value && typeof value === "object") for (const item of Object.values(value)) validateWorkflowExpressions(item, steps);
-}
-
-function boolean(value: unknown): boolean {
-  if (typeof value !== "boolean") throw new WorkflowValueError("EXPRESSION_INVALID", "condition requires a boolean");
-  return value;
-}
-export function workflowCondition(value: unknown, context: Record<string, unknown>): boolean { return boolean(workflowValue(value, context)); }
-
-export function workflowValue(value: unknown, context: Record<string, unknown>): unknown {
-  if (typeof value === "string" && value.startsWith("${{")) {
-    function evaluate(node: jsep.Expression): unknown {
-      if (node.type === "Literal") return (node as jsep.Literal).value;
-      if (node.type === "Identifier") {
-        const name = (node as jsep.Identifier).name;
-        if (!Object.hasOwn(context, name)) throw new MissingPath("EXPRESSION_INVALID", `missing context ${name}`);
-        return context[name];
-      }
-      if (node.type === "CallExpression") {
-        try { evaluate((node as jsep.CallExpression).arguments[0]!); return true; }
-        catch (error) { if (error instanceof MissingPath) return false; throw error; }
-      }
-      if (node.type === "UnaryExpression") {
-        const unary = node as jsep.UnaryExpression;
-        return unary.operator === "!" ? !boolean(evaluate(unary.argument)) : -Number((unary.argument as jsep.Literal).value);
-      }
-      if (node.type === "BinaryExpression") {
-        const { operator, left, right } = node as jsep.BinaryExpression;
-        const a = evaluate(left);
-        if (operator === "&&") return boolean(a) && boolean(evaluate(right));
-        if (operator === "||") return boolean(a) || boolean(evaluate(right));
-        const b = evaluate(right);
-        if ((a !== null && typeof a === "object") || (b !== null && typeof b === "object") || typeof a !== typeof b) throw new WorkflowValueError("EXPRESSION_INVALID", "comparison requires matching scalar types");
-        if (operator === "==") return a === b;
-        if (operator === "!=") return a !== b;
-        if (typeof a === "number" && typeof b === "number") return operator === "<" ? a < b : operator === "<=" ? a <= b : operator === ">" ? a > b : a >= b;
-        if (typeof a === "string" && typeof b === "string") return operator === "<" ? a < b : operator === "<=" ? a <= b : operator === ">" ? a > b : a >= b;
-        throw new WorkflowValueError("EXPRESSION_INVALID", "ordering requires numbers or strings");
-      }
-      const member = node as jsep.MemberExpression;
-      const target = evaluate(member.object);
-      const key = member.computed ? (member.property as jsep.Literal).value : (member.property as jsep.Identifier).name;
-      if (!target || typeof target !== "object" || !Object.hasOwn(target, String(key))) throw new MissingPath("EXPRESSION_INVALID", `missing property ${String(key)}`);
-      return (target as Record<string, unknown>)[String(key)];
-    }
-    return evaluate(expression(value));
-  }
-  if (Array.isArray(value)) return value.map(item => workflowValue(item, context));
-  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, workflowValue(item, context)]));
-  return value;
-}