@wenathlan/devthink 2.0.13 → 2.0.15

package/tests/controlflow.test.ts

@@ -0,0 +1,2120 @@
+import { describe, expect, it } from "vitest";
+import { composeworkflow, newworkflowrun, resolvevariable, runstep, runworkflow, workflowstepof } from "../workflow.js";
+import {
+  applyretry,
+  applyruntimeout,
+  applytimeout,
+  backoffdelay,
+  branchof,
+  cancellederror,
+  choosebranch,
+  conditionof,
+  controlflowkinds,
+  controlsteps,
+  controlsummary,
+  defaultloopbound,
+  evaluatecondition,
+  foreachof,
+  iscontrolflowkind,
+  joinbranches,
+  loopof,
+  parallelof,
+  repeatuntilof,
+  runcontrolstep,
+  tryof,
+  whileof,
+  controlexecutor,
+} from "../workflow.js";
+import { actionrisk, dryrunprojection, isworkflowkind, validatestep } from "../policy.js";
+import { outcomeresponse, parseworkflowproposal, workflowoutcome, workflowreport } from "../protocol.js";
+import { protocolversion } from "../types.js";
+import { loopshare, recordworkflow, workflowevidences } from "../progress.js";
+import { sessionmemory } from "../memory.js";
+import type {
+  agentplan,
+  agentsession,
+  controlflowdecision,
+  retryattempt,
+  runlogentry,
+  timeoutabort,
+  toolstep,
+  variablescope,
+  workflowstep,
+} from "../types.js";
+
+const now = 1_800_000_000_000;
+const session: agentsession = {
+  id: "sess",
+  tabid: 4,
+  origin: "https://example.com",
+  startedat: now - 1000,
+  expiresat: now + 600_000,
+  grants: ["https://example.com"],
+};
+const plan: agentplan = {
+  id: "run",
+  objective: "Run the reviewed workflow with control flow",
+  origin: "https://example.com",
+  steps: [],
+  createdat: now - 2000,
+  expiresat: now + 600_000,
+  state: "approved",
+};
+
+function kindallowed(kind: string): boolean {
+  try {
+    actionrisk(kind as toolstep["kind"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function riskof(kind: string): "read" | "interaction" | "sensitive" {
+  return actionrisk(kind as toolstep["kind"]);
+}
+
+/** Builds one control flow step with its reviewed payload serialized into options. */
+function controlstep(id: string, kind: string, payload: Record<string, unknown>): workflowstep {
+  const parsed = workflowstepof({ id, kind, label: `The ${kind} step`, options: JSON.stringify(payload) });
+  if (!parsed) throw new Error(`The ${kind} step did not normalize.`);
+  return parsed;
+}
+
+/** Builds one plain child step of a control body. */
+function childstep(id: string, label: string, extra: Record<string, unknown> = {}): workflowstep {
+  const parsed = workflowstepof({ id, kind: "wait", label, value: "10", ...extra });
+  if (!parsed) throw new Error(`The child step ${id} did not normalize.`);
+  return parsed;
+}
+
+const rootscope = (
+  variables: Array<{
+    name: string;
+    kind: "string" | "number" | "boolean" | "list" | "element";
+    value: string | number | boolean | string[];
+  }>,
+): variablescope[] => [
+  {
+    name: "root",
+    variables: variables.map((variable) => ({
+      name: variable.name,
+      kind: variable.kind,
+      value: variable.value,
+      setat: now,
+    })),
+  },
+];
+
+class fakeadapter {
+  private readonly data = new Map<string, unknown>();
+  async get<T>(key: string): Promise<T | undefined> {
+    return this.data.get(key) as T | undefined;
+  }
+  async set<T>(key: string, value: T): Promise<void> {
+    this.data.set(key, value);
+  }
+}
+
+describe("control flow kinds and payload grammar", () => {
+  it("lists the control kinds inside the risk table and the workflow family", () => {
+    expect(controlflowkinds).toEqual([
+      "condition",
+      "branch",
+      "loop",
+      "repeatuntil",
+      "whileloop",
+      "foreach",
+      "parallel",
+      "trycatch",
+    ]);
+    for (const kind of controlflowkinds) {
+      expect(iscontrolflowkind(kind)).toBe(true);
+      expect(isworkflowkind(kind as toolstep["kind"])).toBe(true);
+      expect(kindallowed(kind)).toBe(true);
+    }
+    expect(iscontrolflowkind("click")).toBe(false);
+    expect(actionrisk("condition")).toBe("read");
+    expect(actionrisk("branch")).toBe("read");
+    expect(actionrisk("loop")).toBe("interaction");
+    expect(actionrisk("repeatuntil")).toBe("interaction");
+    expect(actionrisk("whileloop")).toBe("interaction");
+    expect(actionrisk("foreach")).toBe("interaction");
+    expect(actionrisk("parallel")).toBe("interaction");
+    expect(actionrisk("trycatch")).toBe("interaction");
+  });
+
+  it("normalizes condition and branch payloads with unique paths and a mandatory else", () => {
+    expect(
+      conditionof({ expression: { left: { ref: "ready" }, operator: "not", result: "stop", resultkind: "boolean" } }),
+    ).toBeDefined();
+    expect(
+      conditionof({
+        expression: {
+          left: { literal: 1 },
+          right: { literal: 2 },
+          operator: "add",
+          result: "sum",
+          resultkind: "number",
+        },
+      }),
+    ).toBeUndefined();
+    expect(conditionof({})).toBeUndefined();
+    const branch = branchof({
+      paths: [
+        {
+          name: "fresh",
+          when: {
+            left: { ref: "count" },
+            right: { literal: 0 },
+            operator: "equal",
+            result: "isfresh",
+            resultkind: "boolean",
+          },
+          steps: [childstep("b1", "Fresh path")],
+        },
+        { name: "always", steps: [childstep("b2", "Unconditional path")] },
+      ],
+      else: { name: "fallback", steps: [] },
+    });
+    if (!branch) throw new Error("The reviewed branch payload did not normalize.");
+    expect(branch.paths).toHaveLength(2);
+    expect(branch.paths[0]?.when?.operator).toBe("equal");
+    expect(branch.paths[1]?.when).toBeUndefined();
+    expect(branch.else.steps).toEqual([]);
+    expect(
+      branchof({
+        paths: [
+          { name: "dup", steps: [childstep("b1", "One")] },
+          { name: "dup", steps: [childstep("b2", "Two")] },
+        ],
+        else: { name: "else", steps: [] },
+      }),
+    ).toBeUndefined();
+    expect(branchof({ paths: [{ name: "only", steps: [childstep("b1", "One")] }] })).toBeUndefined();
+    expect(
+      branchof({ paths: [{ name: "only", steps: [childstep("b1", "One")] }], else: { name: "only", steps: [] } }),
+    ).toBeUndefined();
+    expect(
+      branchof({
+        paths: [
+          {
+            name: "only",
+            when: { left: { literal: 1 }, right: { literal: 1 }, operator: "add", result: "x", resultkind: "number" },
+            steps: [childstep("b1", "One")],
+          },
+        ],
+        else: { name: "else", steps: [] },
+      }),
+    ).toBeUndefined();
+    expect(
+      branchof({
+        paths: [{ name: "only", steps: [childstep("b1", "One")] }],
+        else: { name: "else", steps: [childstep("b2", "Two")] },
+        extra: true,
+      }),
+    ).toBeDefined();
+  });
+
+  it("normalizes loop, repeat until, while and foreach payloads with user configured bounds", () => {
+    expect(
+      loopof({ list: "items", item: "item", index: "index", bound: 50, steps: [childstep("b1", "Body")] }),
+    ).toBeDefined();
+    expect(loopof({ list: "items", item: "item", index: "index", steps: [childstep("b1", "Body")] })).toBeDefined();
+    expect(loopof({ list: "items", item: "items", index: "index", steps: [childstep("b1", "Body")] })).toBeUndefined();
+    expect(loopof({ list: "items", item: "item", index: "item", steps: [childstep("b1", "Body")] })).toBeUndefined();
+    expect(
+      loopof({ list: "items", item: "item", index: "index", bound: 0, steps: [childstep("b1", "Body")] }),
+    ).toBeUndefined();
+    expect(
+      loopof({ list: "items", item: "item", index: "index", bound: 2.5, steps: [childstep("b1", "Body")] }),
+    ).toBeUndefined();
+    expect(loopof({ list: "items", item: "item", index: "index", steps: [] })).toBeUndefined();
+    expect(
+      repeatuntilof({
+        until: {
+          left: { ref: "count" },
+          right: { literal: 3 },
+          operator: "greaterequal",
+          result: "done",
+          resultkind: "boolean",
+        },
+        bound: 10,
+        steps: [childstep("b1", "Body")],
+      }),
+    ).toBeDefined();
+    expect(
+      repeatuntilof({
+        until: { left: { literal: 1 }, right: { literal: 2 }, operator: "add", result: "n", resultkind: "number" },
+        steps: [childstep("b1", "Body")],
+      }),
+    ).toBeUndefined();
+    expect(
+      whileof({
+        while: { left: { ref: "count" }, right: { literal: 3 }, operator: "less", result: "go", resultkind: "boolean" },
+        bound: 4,
+        steps: [childstep("b1", "Body")],
+      }),
+    ).toBeDefined();
+    expect(
+      whileof({
+        while: { left: { ref: "count" }, right: { literal: 3 }, operator: "less", result: "go", resultkind: "boolean" },
+        steps: [childstep("b1", "Body")],
+      }),
+    ).toBeUndefined();
+    expect(
+      foreachof({ selector: "li.item", item: "row", index: "rowindex", steps: [childstep("b1", "Body")] }),
+    ).toBeDefined();
+    expect(
+      foreachof({ selector: " ", item: "row", index: "rowindex", steps: [childstep("b1", "Body")] }),
+    ).toBeUndefined();
+    expect(
+      foreachof({ selector: "li.item", item: "row", index: "row", steps: [childstep("b1", "Body")] }),
+    ).toBeUndefined();
+  });
+
+  it("normalizes parallel and try payloads with join, retry and timeout policies", () => {
+    expect(
+      parallelof({
+        branches: [
+          { id: "one", steps: [childstep("a1", "A")] },
+          { id: "two", steps: [childstep("b1", "B")] },
+        ],
+        join: { strategy: "last", onfail: "cancel" },
+      }),
+    ).toBeDefined();
+    expect(
+      parallelof({
+        branches: [
+          { id: "one", steps: [childstep("a1", "A")] },
+          { id: "one", steps: [childstep("b1", "B")] },
+        ],
+        join: { strategy: "first", onfail: "continue" },
+      }),
+    ).toBeUndefined();
+    expect(
+      parallelof({
+        branches: [{ id: "one", steps: [childstep("a1", "A")] }],
+        join: { strategy: "merge", onfail: "continue" },
+      }),
+    ).toBeUndefined();
+    expect(
+      parallelof({
+        branches: [{ id: "one", steps: [childstep("a1", "A")] }],
+        join: { strategy: "fail", onfail: "ignore" },
+      }),
+    ).toBeUndefined();
+    expect(
+      tryof({ steps: [childstep("f1", "Fragile")], catch: { steps: [childstep("c1", "Handler")] } }),
+    ).toBeDefined();
+    expect(
+      tryof({
+        steps: [childstep("f1", "Fragile")],
+        catch: { steps: [childstep("c1", "Handler")], rerun: true },
+        retry: {
+          attempts: 5,
+          backoff: { shape: "exponential", base: 100, jitter: 20 },
+          retryable: ["timeout", "pageunresponsive"],
+        },
+        timeout: { stepms: 4000, runms: 30000 },
+      }),
+    ).toBeDefined();
+    expect(tryof({ steps: [childstep("f1", "Fragile")] })).toBeUndefined();
+    expect(tryof({ steps: [childstep("f1", "Fragile")], catch: { steps: [] } })).toBeUndefined();
+    expect(
+      tryof({
+        steps: [childstep("f1", "Fragile")],
+        catch: { steps: [childstep("c1", "Handler")] },
+        retry: { attempts: 0, backoff: { shape: "fixed", base: 0, jitter: 0 }, retryable: ["timeout"] },
+      }),
+    ).toBeUndefined();
+    expect(
+      tryof({
+        steps: [childstep("f1", "Fragile")],
+        catch: { steps: [childstep("c1", "Handler")] },
+        retry: { attempts: 2, backoff: { shape: "wave", base: 0, jitter: 0 }, retryable: ["timeout"] },
+      }),
+    ).toBeUndefined();
+    expect(
+      tryof({
+        steps: [childstep("f1", "Fragile")],
+        catch: { steps: [childstep("c1", "Handler")] },
+        retry: { attempts: 2, backoff: { shape: "fixed", base: -1, jitter: 0 }, retryable: ["timeout"] },
+      }),
+    ).toBeUndefined();
+    expect(
+      tryof({
+        steps: [childstep("f1", "Fragile")],
+        catch: { steps: [childstep("c1", "Handler")] },
+        timeout: { stepms: -5 },
+      }),
+    ).toBeUndefined();
+    expect(
+      tryof({ steps: [childstep("f1", "Fragile")], catch: { steps: [childstep("c1", "Handler")] }, timeout: {} }),
+    ).toBeUndefined();
+  });
+
+  it("collects every nested child step of a control payload recursively", () => {
+    const nested = controlstep("l1", "loop", {
+      loop: {
+        list: "items",
+        item: "item",
+        index: "index",
+        steps: [
+          childstep("b1", "Body read"),
+          controlstep("p1", "parallel", {
+            parallel: {
+              branches: [
+                { id: "one", steps: [childstep("a1", "Lane one")] },
+                { id: "two", steps: [childstep("a2", "Lane two")] },
+              ],
+              join: { strategy: "first", onfail: "continue" },
+            },
+          }),
+          controlstep("t1", "trycatch", {
+            try: { steps: [childstep("f1", "Fragile")], catch: { steps: [childstep("c1", "Handler")] } },
+          }),
+        ],
+      },
+    });
+    const children = controlsteps(nested);
+    expect(children.map((child) => child.id)).toEqual(["b1", "p1", "a1", "a2", "t1", "f1", "c1"]);
+    expect(controlsteps(childstep("b1", "Plain"))).toEqual([]);
+    const malformed = controlstep("l1", "loop", { loop: { list: "items", item: "item", index: "index" } });
+    expect(controlsteps(malformed)).toEqual([]);
+  });
+
+  it("summarizes every control kind for the review panel", () => {
+    expect(
+      controlsummary(
+        controlstep("c1", "condition", {
+          condition: { expression: { left: { ref: "ready" }, operator: "not", result: "stop", resultkind: "boolean" } },
+        }),
+      ),
+    ).toMatchObject({ kind: "condition", expression: expect.stringContaining("not") });
+    expect(
+      controlsummary(
+        controlstep("b1", "branch", {
+          branch: { paths: [{ name: "fast", steps: [childstep("x1", "Fast")] }], else: { name: "slow", steps: [] } },
+        }),
+      ),
+    ).toMatchObject({ kind: "branch", paths: ["fast"], elsepath: "slow" });
+    expect(
+      controlsummary(
+        controlstep("l1", "loop", {
+          loop: { list: "items", item: "item", index: "index", steps: [childstep("x1", "Body")] },
+        }),
+      ),
+    ).toMatchObject({ kind: "loop", list: "items", item: "item", index: "index", bound: defaultloopbound });
+    expect(
+      controlsummary(
+        controlstep("w1", "whileloop", {
+          while: {
+            while: { left: { literal: true }, operator: "not", result: "go", resultkind: "boolean" },
+            bound: 7,
+            steps: [childstep("x1", "Body")],
+          },
+        }),
+      ),
+    ).toMatchObject({ kind: "whileloop", bound: 7 });
+    expect(
+      controlsummary(
+        controlstep("p1", "parallel", {
+          parallel: {
+            branches: [
+              { id: "one", steps: [childstep("x1", "One")] },
+              { id: "two", steps: [childstep("x2", "Two")] },
+            ],
+            join: { strategy: "fail", onfail: "cancel" },
+          },
+        }),
+      ),
+    ).toMatchObject({ kind: "parallel", branches: ["one", "two"], strategy: "fail", onfail: "cancel" });
+    expect(
+      controlsummary(
+        controlstep("t1", "trycatch", {
+          try: {
+            steps: [childstep("f1", "Fragile")],
+            catch: { steps: [childstep("c1", "Handler")], rerun: true },
+            retry: { attempts: 3, backoff: { shape: "exponential", base: 100, jitter: 10 }, retryable: ["timeout"] },
+            timeout: { stepms: 500, runms: 5000 },
+          },
+        }),
+      ),
+    ).toMatchObject({ kind: "trycatch", attempts: 3, rerun: true, stepms: 500, runms: 5000 });
+    expect(controlsummary(childstep("b1", "Plain"))).toBeUndefined();
+  });
+});
+
+describe("condition and branch evaluation", () => {
+  it("evaluates conditions over extracted values with no page side effect", () => {
+    const condition = conditionof({
+      expression: {
+        left: { ref: "count" },
+        right: { literal: 3 },
+        operator: "greaterequal",
+        result: "done",
+        resultkind: "boolean",
+      },
+    });
+    if (!condition) throw new Error("The condition payload did not normalize.");
+    expect(evaluatecondition(condition, rootscope([{ name: "count", kind: "number", value: 3 }]))).toBe(true);
+    expect(evaluatecondition(condition, rootscope([{ name: "count", kind: "number", value: 2 }]))).toBe(false);
+    expect(() => evaluatecondition(condition, rootscope([]))).toThrow("undefined variable count");
+    expect(() =>
+      evaluatecondition(
+        {
+          expression: {
+            left: { literal: 1 },
+            right: { literal: 2 },
+            operator: "add",
+            result: "sum",
+            resultkind: "boolean",
+          },
+        },
+        [],
+      ),
+    ).toThrow("boolean");
+  });
+
+  it("chooses the first matching branch path and falls back to the else path", () => {
+    const branch = branchof({
+      paths: [
+        {
+          name: "empty",
+          when: {
+            left: { ref: "count" },
+            right: { literal: 0 },
+            operator: "equal",
+            result: "isempty",
+            resultkind: "boolean",
+          },
+          steps: [childstep("b1", "Empty path")],
+        },
+        {
+          name: "small",
+          when: {
+            left: { ref: "count" },
+            right: { literal: 10 },
+            operator: "less",
+            result: "issmall",
+            resultkind: "boolean",
+          },
+          steps: [childstep("b2", "Small path")],
+        },
+      ],
+      else: { name: "large", steps: [childstep("b3", "Large path")] },
+    });
+    if (!branch) throw new Error("The branch payload did not normalize.");
+    const empty = choosebranch({
+      stepid: "br1",
+      branch,
+      scopes: rootscope([{ name: "count", kind: "number", value: 0 }]),
+      now,
+    });
+    expect(empty.outcome.path).toBe("empty");
+    expect(empty.outcome.reason).toContain("condition of the path empty holds");
+    expect(empty.steps.map((step) => step.id)).toEqual(["b1"]);
+    const small = choosebranch({
+      stepid: "br1",
+      branch,
+      scopes: rootscope([{ name: "count", kind: "number", value: 5 }]),
+      now,
+    });
+    expect(small.outcome.path).toBe("small");
+    const fallback = choosebranch({
+      stepid: "br1",
+      branch,
+      scopes: rootscope([{ name: "count", kind: "number", value: 50 }]),
+      now,
+    });
+    expect(fallback.outcome.path).toBe("large");
+    expect(fallback.outcome.reason).toContain("No path condition held");
+    expect(fallback.steps.map((step) => step.id)).toEqual(["b3"]);
+    expect(fallback.outcome.at).toBe(now);
+  });
+
+  it("matches branch paths over the page state of the snapshot accessor", () => {
+    const branch = branchof({
+      paths: [
+        {
+          name: "ready",
+          when: { left: { ref: "pageready" }, operator: "not", result: "notready", resultkind: "boolean" },
+          steps: [childstep("b1", "Wait for load")],
+        },
+        {
+          name: "shop",
+          when: {
+            left: { ref: "pageurl" },
+            right: { literal: "https://shop.example.com/cart" },
+            operator: "equal",
+            result: "oncart",
+            resultkind: "boolean",
+          },
+          steps: [childstep("b2", "Cart path")],
+        },
+      ],
+      else: { name: "other", steps: [] },
+    });
+    if (!branch) throw new Error("The branch payload did not normalize.");
+    const ready = choosebranch({
+      stepid: "br1",
+      branch,
+      scopes: rootscope([]),
+      pagestate: { url: "https://shop.example.com/cart", ready: true },
+      now,
+    });
+    expect(ready.outcome.path).toBe("shop");
+    const loading = choosebranch({
+      stepid: "br1",
+      branch,
+      scopes: rootscope([]),
+      pagestate: { url: "https://example.com", ready: false },
+      now,
+    });
+    expect(loading.outcome.path).toBe("ready");
+    const other = choosebranch({
+      stepid: "br1",
+      branch,
+      scopes: rootscope([]),
+      pagestate: { url: "https://other.example.com", ready: true },
+      now,
+    });
+    expect(other.outcome.path).toBe("other");
+  });
+});
+
+describe("loop family runners", () => {
+  const execute = async (dispatched: workflowstep): Promise<{ ok: boolean; summary: string }> => ({
+    ok: true,
+    summary: `ran ${dispatched.id}`,
+  });
+
+  it("iterates a list variable rebinding the item and index per iteration", async () => {
+    const step = controlstep("l1", "loop", {
+      loop: {
+        list: "items",
+        item: "item",
+        index: "index",
+        bound: 10,
+        steps: [
+          workflowstepof({
+            id: "b1",
+            kind: "wait",
+            label: "Read the row",
+            value: "row ${item} at ${index}",
+          }) as workflowstep,
+        ],
+      },
+    });
+    const seen: string[] = [];
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([{ name: "items", kind: "list", value: ["a", "b", "c"] }]),
+      outputs: {},
+      execute: async (dispatched) => {
+        seen.push(`${dispatched.id}:${dispatched.value}`);
+        return { ok: true, summary: "ok" };
+      },
+      now,
+    });
+    expect(result.output.ok).toBe(true);
+    expect(seen).toEqual(["b1:row a at 0", "b1:row b at 1", "b1:row c at 2"]);
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.kind).toBe("loop");
+    expect(decision.loops?.map((counter) => counter.iteration)).toEqual([0, 1, 2]);
+    expect(result.log.some((entry) => entry.label.includes("iteration 2"))).toBe(true);
+    expect(
+      result.log.some(
+        (entry) => entry.details !== undefined && (entry.details as { iteration?: number }).iteration === 1,
+      ),
+    ).toBe(true);
+  });
+
+  it("refuses a list longer than the reviewed bound with nothing running and reports the overflow", async () => {
+    const step = controlstep("l1", "loop", {
+      loop: { list: "items", item: "item", index: "index", bound: 2, steps: [childstep("b1", "Body")] },
+    });
+    let runs = 0;
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([{ name: "items", kind: "list", value: ["a", "b", "c"] }]),
+      outputs: {},
+      execute: async () => {
+        runs += 1;
+        return { ok: true, summary: "never" };
+      },
+      now,
+    });
+    expect(result.output.ok).toBe(false);
+    expect(result.output.summary).toContain("exceeds the reviewed safety bound of 2");
+    expect(runs).toBe(0);
+  });
+
+  it("fails the loop when an iteration fails and keeps the counters of the passes", async () => {
+    const step = controlstep("l1", "loop", {
+      loop: { list: "items", item: "item", index: "index", steps: [childstep("b1", "Body")] },
+    });
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([{ name: "items", kind: "list", value: ["a", "b"] }]),
+      outputs: {},
+      execute: async (dispatched) =>
+        dispatched.value === "10" && dispatched.id === "b1"
+          ? { ok: dispatched.id === "b1" ? false : true, summary: dispatched.id === "b1" ? "the row refused" : "ok" }
+          : { ok: true, summary: "ok" },
+      now,
+    });
+    expect(result.output.ok).toBe(false);
+    expect(result.output.summary).toContain("failed at iteration 1");
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.loops?.at(0)?.ok).toBe(false);
+  });
+
+  it("runs nested loops tracking the outer and inner index paths for audit", async () => {
+    const inner = controlstep("l2", "loop", {
+      loop: {
+        list: "columns",
+        item: "column",
+        index: "columnindex",
+        steps: [
+          workflowstepof({
+            id: "b2",
+            kind: "wait",
+            label: "Read the cell",
+            value: "cell ${item}${column}",
+          }) as workflowstep,
+        ],
+      },
+    });
+    const outer = controlstep("l1", "loop", { loop: { list: "items", item: "item", index: "index", steps: [inner] } });
+    const seen: string[] = [];
+    const result = await runcontrolstep({
+      step: outer,
+      scopes: rootscope([
+        { name: "items", kind: "list", value: ["a", "b"] },
+        { name: "columns", kind: "list", value: ["1", "2"] },
+      ]),
+      outputs: {},
+      execute: async (dispatched) => {
+        seen.push(`${dispatched.value}`);
+        return { ok: true, summary: "ok" };
+      },
+      now,
+    });
+    expect(seen).toEqual(["cell a1", "cell a2", "cell b1", "cell b2"]);
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.loops?.map((counter) => counter.path)).toEqual(["l1[0]", "l1[1]"]);
+    const innerlog = result.log.filter((entry) => entry.stepid === "l2");
+    expect(innerlog.length).toBeGreaterThanOrEqual(4);
+  });
+
+  it("runs repeat until convergence inside the bound and reports the overflow honestly", async () => {
+    const converging = controlstep("r1", "repeatuntil", {
+      repeatuntil: {
+        until: {
+          left: { ref: "count" },
+          right: { literal: 3 },
+          operator: "greaterequal",
+          result: "done",
+          resultkind: "boolean",
+        },
+        bound: 8,
+        steps: [
+          workflowstepof({
+            id: "b1",
+            kind: "wait",
+            label: "Nudge the counter",
+            value: "1",
+            expression: {
+              left: { ref: "count" },
+              right: { literal: 1 },
+              operator: "add",
+              result: "count",
+              resultkind: "number",
+            },
+          }) as workflowstep,
+        ],
+      },
+    });
+    const converged = await runcontrolstep({
+      step: converging,
+      scopes: rootscope([{ name: "count", kind: "number", value: 0 }]),
+      outputs: {},
+      execute,
+      now,
+    });
+    expect(converged.output.ok).toBe(true);
+    expect(converged.output.summary).toContain("converged after 3 iterations");
+    const decision = converged.output.details?.control as controlflowdecision;
+    expect(decision.loops).toHaveLength(3);
+
+    const stuck = controlstep("r1", "repeatuntil", {
+      repeatuntil: {
+        until: { left: { literal: true }, operator: "not", result: "never", resultkind: "boolean" },
+        bound: 2,
+        steps: [childstep("b1", "Body")],
+      },
+    });
+    const overflow = await runcontrolstep({ step: stuck, scopes: rootscope([]), outputs: {}, execute, now });
+    expect(overflow.output.ok).toBe(false);
+    expect(overflow.output.summary).toContain("never converged within the reviewed safety bound of 2");
+  });
+
+  it("runs while loops that end when the condition stops and refuses the endless ones at the bound", async () => {
+    const ending = controlstep("w1", "whileloop", {
+      while: {
+        while: { left: { ref: "count" }, right: { literal: 3 }, operator: "less", result: "go", resultkind: "boolean" },
+        bound: 10,
+        steps: [
+          workflowstepof({
+            id: "b1",
+            kind: "wait",
+            label: "Grow the counter",
+            value: "1",
+            expression: {
+              left: { ref: "count" },
+              right: { literal: 1 },
+              operator: "add",
+              result: "count",
+              resultkind: "number",
+            },
+          }) as workflowstep,
+        ],
+      },
+    });
+    const ended = await runcontrolstep({
+      step: ending,
+      scopes: rootscope([{ name: "count", kind: "number", value: 0 }]),
+      outputs: {},
+      execute,
+      now,
+    });
+    expect(ended.output.ok).toBe(true);
+    expect(ended.output.summary).toContain("ended after 3 iterations");
+    expect(resolvevariable(ended.scopes, "count")?.value).toBe(3);
+
+    const endless = controlstep("w1", "whileloop", {
+      while: {
+        while: { left: { literal: false }, operator: "not", result: "forever", resultkind: "boolean" },
+        bound: 2,
+        steps: [childstep("b1", "Body")],
+      },
+    });
+    const overflow = await runcontrolstep({ step: endless, scopes: rootscope([]), outputs: {}, execute, now });
+    expect(overflow.output.ok).toBe(false);
+    expect(overflow.output.summary).toContain(
+      "hit its reviewed safety bound of 2 iterations while its condition still held",
+    );
+
+    const nevers = controlstep("w1", "whileloop", {
+      while: {
+        while: { left: { literal: true }, operator: "not", result: "never", resultkind: "boolean" },
+        bound: 4,
+        steps: [childstep("b1", "Body")],
+      },
+    });
+    const zero = await runcontrolstep({
+      step: nevers,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async () => {
+        throw new Error("never");
+      },
+      now,
+    });
+    expect(zero.output.ok).toBe(true);
+    expect(zero.output.summary).toContain("ended after 0 iterations");
+  });
+
+  it("runs foreach over matched elements and reports the empty match as zero iterations", async () => {
+    const step = controlstep("f1", "foreach", {
+      foreach: {
+        selector: "li.row",
+        item: "row",
+        index: "rowindex",
+        steps: [
+          workflowstepof({
+            id: "b1",
+            kind: "wait",
+            label: "Read the element",
+            value: "element ${row} at ${rowindex}",
+          }) as workflowstep,
+        ],
+      },
+    });
+    const seen: string[] = [];
+    const filled = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async (dispatched) => {
+        seen.push(`${dispatched.value}`);
+        return { ok: true, summary: "ok" };
+      },
+      now,
+      resolveelements: async (selector) =>
+        selector === "li.row" ? ["li.row:nth-of-type(1)", "li.row:nth-of-type(2)"] : [],
+    });
+    expect(filled.output.ok).toBe(true);
+    expect(seen).toEqual(["element li.row:nth-of-type(1) at 0", "element li.row:nth-of-type(2) at 1"]);
+    expect(resolvevariable(filled.scopes, "row")?.kind).toBe("element");
+
+    const empty = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute,
+      now,
+      resolveelements: async () => [],
+    });
+    expect(empty.output.ok).toBe(true);
+    expect(empty.output.summary).toContain("matched no element and the foreach ran zero iterations");
+
+    await expect(runcontrolstep({ step, scopes: rootscope([]), outputs: {}, execute, now })).rejects.toThrow(
+      "element resolver",
+    );
+  });
+});
+
+describe("parallel branches and joins", () => {
+  it("runs branches concurrently with isolated scopes and merges their writes at the join", async () => {
+    const step = controlstep("p1", "parallel", {
+      parallel: {
+        branches: [
+          {
+            id: "one",
+            steps: [
+              workflowstepof({
+                id: "a1",
+                kind: "wait",
+                label: "Lane one",
+                value: "1",
+                expression: {
+                  left: { literal: 10 },
+                  right: { literal: 1 },
+                  operator: "add",
+                  result: "firsttotal",
+                  resultkind: "number",
+                },
+              }) as workflowstep,
+            ],
+          },
+          {
+            id: "two",
+            steps: [
+              workflowstepof({
+                id: "b1",
+                kind: "wait",
+                label: "Lane two",
+                value: "2",
+                expression: {
+                  left: { literal: 20 },
+                  right: { literal: 2 },
+                  operator: "add",
+                  result: "secondtotal",
+                  resultkind: "number",
+                },
+              }) as workflowstep,
+            ],
+          },
+        ],
+        join: { strategy: "last", onfail: "continue" },
+      },
+    });
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async () => ({ ok: true, summary: "lane ok" }),
+      now,
+    });
+    expect(result.output.ok).toBe(true);
+    expect(result.output.summary).toContain("ran 2 concurrent branches");
+    expect(resolvevariable(result.scopes, "firsttotal")?.value).toBe(11);
+    expect(resolvevariable(result.scopes, "secondtotal")?.value).toBe(22);
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.kind).toBe("join");
+    expect(decision.join?.strategy).toBe("last");
+    expect(decision.join?.conflicts).toEqual([]);
+    expect(decision.join?.merged).toEqual(["firsttotal", "secondtotal"]);
+    expect(decision.branches?.map((outcome) => outcome.branchid)).toEqual(["one", "two"]);
+  });
+
+  it("keeps sibling variables invisible across the isolated branch scopes", async () => {
+    const step = controlstep("p1", "parallel", {
+      parallel: {
+        branches: [
+          {
+            id: "one",
+            steps: [
+              workflowstepof({
+                id: "a1",
+                kind: "wait",
+                label: "Lane one",
+                value: "1",
+                expression: {
+                  left: { literal: 1 },
+                  right: { literal: 1 },
+                  operator: "add",
+                  result: "sibling",
+                  resultkind: "number",
+                },
+              }) as workflowstep,
+            ],
+          },
+          {
+            id: "two",
+            steps: [
+              workflowstepof({
+                id: "b1",
+                kind: "wait",
+                label: "Read the sibling",
+                value: "value ${sibling}",
+              }) as workflowstep,
+            ],
+          },
+        ],
+        join: { strategy: "last", onfail: "continue" },
+      },
+    });
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async () => ({ ok: true, summary: "lane ok" }),
+      now,
+    });
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.branches?.find((outcome) => outcome.branchid === "two")?.ok).toBe(false);
+    expect(result.output.summary).toContain("merged 1 variable");
+  });
+
+  it("resolves join conflicts under the first, last and fail strategies", () => {
+    const branches = [
+      {
+        id: "one",
+        order: 0,
+        ok: true,
+        cancelled: false,
+        variables: [
+          { name: "shared", kind: "string" as const, value: "first lane", setat: now },
+          { name: "onlyone", kind: "number" as const, value: 1, setat: now },
+        ],
+      },
+      {
+        id: "two",
+        order: 1,
+        ok: true,
+        cancelled: false,
+        variables: [{ name: "shared", kind: "string" as const, value: "second lane", setat: now }],
+      },
+    ];
+    const last = joinbranches({ stepid: "p1", branches, strategy: "last", now });
+    expect(last.ok).toBe(true);
+    expect(last.merged.find((variable) => variable.name === "shared")?.value).toBe("second lane");
+    expect(last.conflicts).toEqual(["shared"]);
+    expect(last.summary).toContain("resolved by the strategy");
+    const first = joinbranches({ stepid: "p1", branches, strategy: "first", now });
+    expect(first.ok).toBe(true);
+    expect(first.merged.find((variable) => variable.name === "shared")?.value).toBe("first lane");
+    const failed = joinbranches({ stepid: "p1", branches, strategy: "fail", now });
+    expect(failed.ok).toBe(false);
+    expect(failed.conflicts).toEqual(["shared"]);
+    expect(failed.summary).toContain("refused the conflicting writes of shared");
+    const cancelledbranch = { id: "one", order: 0, ok: true, cancelled: true, variables: branches[0]!.variables };
+    const cancelledonly = joinbranches({ stepid: "p1", branches: [cancelledbranch], strategy: "fail", now });
+    expect(cancelledonly.ok).toBe(true);
+    expect(cancelledonly.merged).toEqual([]);
+  });
+
+  it("cancels or continues sibling branches under the reviewed join policy on branch failure", async () => {
+    const payload = (onfail: "cancel" | "continue"): workflowstep =>
+      controlstep("p1", "parallel", {
+        parallel: {
+          branches: [
+            { id: "one", steps: [childstep("a1", "Failing lane")] },
+            {
+              id: "two",
+              steps: [
+                workflowstepof({
+                  id: "b1",
+                  kind: "wait",
+                  label: "Sibling lane",
+                  value: "2",
+                  expression: {
+                    left: { literal: 2 },
+                    right: { literal: 2 },
+                    operator: "add",
+                    result: "siblingtotal",
+                    resultkind: "number",
+                  },
+                }) as workflowstep,
+              ],
+            },
+          ],
+          join: { strategy: "last", onfail },
+        },
+      });
+    const failing = async (dispatched: workflowstep): Promise<{ ok: boolean; summary: string }> =>
+      dispatched.id === "a1" ? { ok: false, summary: "the lane failed" } : { ok: true, summary: "lane ok" };
+    const cancelled = await runcontrolstep({
+      step: payload("cancel"),
+      scopes: rootscope([]),
+      outputs: {},
+      execute: failing,
+      now,
+    });
+    expect(cancelled.output.ok).toBe(false);
+    expect(cancelled.output.summary).toContain("failed on branch one");
+    const decision = cancelled.output.details?.control as controlflowdecision;
+    expect(decision.branches?.find((outcome) => outcome.branchid === "two")?.cancelled).toBe(true);
+    expect(decision.join?.merged).toEqual([]);
+
+    const continued = await runcontrolstep({
+      step: payload("continue"),
+      scopes: rootscope([]),
+      outputs: {},
+      execute: failing,
+      now,
+    });
+    expect(continued.output.ok).toBe(true);
+    expect(resolvevariable(continued.scopes, "siblingtotal")?.value).toBe(4);
+    const continuedecision = continued.output.details?.control as controlflowdecision;
+    expect(continuedecision.branches?.find((outcome) => outcome.branchid === "one")?.ok).toBe(false);
+  });
+
+  it("refuses the whole parallel block when the fail strategy meets conflicting writes", async () => {
+    const step = controlstep("p1", "parallel", {
+      parallel: {
+        branches: [
+          {
+            id: "one",
+            steps: [
+              workflowstepof({
+                id: "a1",
+                kind: "wait",
+                label: "Lane one",
+                value: "1",
+                expression: {
+                  left: { literal: 1 },
+                  right: { literal: 1 },
+                  operator: "add",
+                  result: "shared",
+                  resultkind: "number",
+                },
+              }) as workflowstep,
+            ],
+          },
+          {
+            id: "two",
+            steps: [
+              workflowstepof({
+                id: "b1",
+                kind: "wait",
+                label: "Lane two",
+                value: "2",
+                expression: {
+                  left: { literal: 2 },
+                  right: { literal: 2 },
+                  operator: "add",
+                  result: "shared",
+                  resultkind: "number",
+                },
+              }) as workflowstep,
+            ],
+          },
+        ],
+        join: { strategy: "fail", onfail: "continue" },
+      },
+    });
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async () => ({ ok: true, summary: "lane ok" }),
+      now,
+    });
+    expect(result.output.ok).toBe(false);
+    expect(result.output.summary).toContain("refused the conflicting writes of shared under the fail strategy");
+  });
+});
+
+describe("try catch with retries and timeouts", () => {
+  it("runs the catch handler after a fragile failure and reruns the body once on demand", async () => {
+    const step = controlstep("t1", "trycatch", {
+      try: { steps: [childstep("f1", "Fragile step")], catch: { steps: [childstep("c1", "Handler step")] } },
+    });
+    const plain = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async (dispatched) =>
+        dispatched.id === "f1" ? { ok: false, summary: "the page refused" } : { ok: true, summary: "handled" },
+      now,
+    });
+    expect(plain.output.ok).toBe(true);
+    expect(plain.output.summary).toContain("The catch handler ran 1 step after the stepfailed failure");
+    const decision = plain.output.details?.control as controlflowdecision;
+    expect(decision.kind).toBe("catch");
+    expect(decision.catch?.errorclass).toBe("stepfailed");
+    expect(decision.catch?.message).toBe("the page refused");
+    expect(decision.catch?.rerun).toBe(false);
+
+    const rerunstep = controlstep("t1", "trycatch", {
+      try: {
+        steps: [childstep("f1", "Fragile step")],
+        catch: { steps: [childstep("c1", "Handler step")], rerun: true },
+      },
+    });
+    let attempts = 0;
+    const rerun = await runcontrolstep({
+      step: rerunstep,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async (dispatched) => {
+        if (dispatched.id === "f1") {
+          attempts += 1;
+          return { ok: attempts > 1, summary: attempts > 1 ? "recovered" : "flaky" };
+        }
+        return { ok: true, summary: "handled" };
+      },
+      now,
+    });
+    expect(rerun.output.ok).toBe(true);
+    expect(rerun.output.summary).toContain("rerun of the try body succeeded");
+    expect(attempts).toBe(2);
+    const rerundecision = rerun.output.details?.control as controlflowdecision;
+    expect(rerundecision.catch?.rerun).toBe(true);
+  });
+
+  it("captures the reviewed error class for the handler and fails when the handler fails", async () => {
+    const step = controlstep("t1", "trycatch", {
+      try: { steps: [childstep("f1", "Fragile step")], catch: { steps: [childstep("c1", "Handler step")] } },
+    });
+    const classy = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async (dispatched) =>
+        dispatched.id === "f1"
+          ? { ok: false, summary: "the page went away", details: { errorclass: "pageunresponsive" } }
+          : { ok: true, summary: "handled" },
+      now,
+    });
+    const classydecision = classy.output.details?.control as controlflowdecision;
+    expect(classydecision.catch?.errorclass).toBe("pageunresponsive");
+
+    const failinghandler = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async () => ({ ok: false, summary: "handler also failed" }),
+      now,
+    });
+    expect(failinghandler.output.ok).toBe(false);
+    expect(failinghandler.output.summary).toContain("catch handler of the try block failed");
+  });
+
+  it("retries a failed step under the policy with fixed and exponential backoff shapes", async () => {
+    const policy = {
+      attempts: 3,
+      backoff: { shape: "exponential" as const, base: 10, jitter: 0 },
+      retryable: ["pageunresponsive"],
+    };
+    let calls = 0;
+    const recovered = await applyretry({
+      stepid: "f1",
+      policy,
+      now,
+      run: async () => {
+        calls += 1;
+        return { ok: calls >= 3, details: { errorclass: "pageunresponsive" } };
+      },
+      errorclass: (value) => String(value.details?.errorclass ?? "stepfailed"),
+    });
+    expect(calls).toBe(3);
+    expect(recovered.value.ok).toBe(true);
+    expect(recovered.attempts.map((attempt) => attempt.delay)).toEqual([10, 20]);
+    expect(recovered.attempts.map((attempt) => attempt.errorclass)).toEqual(["pageunresponsive", "pageunresponsive"]);
+    expect(recovered.exhausted).toBe(false);
+
+    let failures = 0;
+    const exhausted = await applyretry({
+      stepid: "f1",
+      policy,
+      now,
+      run: async () => {
+        failures += 1;
+        return { ok: false, details: { errorclass: "pageunresponsive" } };
+      },
+      errorclass: (value) => String(value.details?.errorclass ?? "stepfailed"),
+    });
+    expect(failures).toBe(3);
+    expect(exhausted.exhausted).toBe(true);
+    expect(exhausted.value.ok).toBe(false);
+
+    let once = 0;
+    const nonretryable = await applyretry({
+      stepid: "f1",
+      policy,
+      now,
+      run: async () => {
+        once += 1;
+        return { ok: false, details: { errorclass: "permissiondenied" } };
+      },
+      errorclass: (value) => String(value.details?.errorclass ?? "stepfailed"),
+    });
+    expect(once).toBe(1);
+    expect(nonretryable.attempts).toEqual([]);
+    expect(nonretryable.exhausted).toBe(false);
+
+    expect(backoffdelay({ attempts: 3, backoff: { shape: "fixed", base: 100, jitter: 0 }, retryable: [] }, 2, 1)).toBe(
+      100,
+    );
+    expect(
+      backoffdelay({ attempts: 3, backoff: { shape: "exponential", base: 25, jitter: 0 }, retryable: [] }, 3, 1),
+    ).toBe(100);
+    for (let seed = 1; seed <= 50; seed += 1) {
+      const jittered = backoffdelay(
+        { attempts: 3, backoff: { shape: "fixed", base: 100, jitter: 40 }, retryable: [] },
+        1,
+        seed,
+      );
+      expect(jittered).toBeGreaterThanOrEqual(80);
+      expect(jittered).toBeLessThanOrEqual(120);
+    }
+  });
+
+  it("runs the retry policy of a try block over its children with the attempts recorded", async () => {
+    const step = controlstep("t1", "trycatch", {
+      try: {
+        steps: [childstep("f1", "Fragile step")],
+        catch: { steps: [childstep("c1", "Handler step")] },
+        retry: { attempts: 3, backoff: { shape: "fixed", base: 0, jitter: 0 }, retryable: ["pageunresponsive"] },
+      },
+    });
+    let calls = 0;
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async (dispatched) => {
+        if (dispatched.id === "f1") {
+          calls += 1;
+          return {
+            ok: calls >= 3,
+            summary: calls >= 3 ? "recovered" : "flaky",
+            details: { errorclass: "pageunresponsive" },
+          };
+        }
+        return { ok: true, summary: "handled" };
+      },
+      now,
+    });
+    expect(result.output.ok).toBe(true);
+    expect(result.output.summary).toContain("after 2 retry attempts");
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.kind).toBe("retry");
+    expect(decision.retries?.map((attempt) => attempt.stepid)).toEqual(["f1", "f1"]);
+  });
+
+  it("aborts one step that exceeds its per step budget and hands it to the catch handler", async () => {
+    const step = controlstep("t1", "trycatch", {
+      try: {
+        steps: [childstep("f1", "Slow step")],
+        catch: { steps: [childstep("c1", "Handler step")] },
+        timeout: { stepms: 10 },
+      },
+    });
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async (dispatched) => {
+        if (dispatched.id === "f1") await new Promise((resolve) => setTimeout(resolve, 40));
+        return { ok: true, summary: "slow done" };
+      },
+      now,
+    });
+    expect(result.output.ok).toBe(true);
+    expect(result.output.summary).toContain("catch handler ran");
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.timeouts).toHaveLength(1);
+    expect(decision.timeouts?.[0]?.budget).toBe(10);
+    expect(decision.timeouts?.[0]?.scope).toBe("step");
+  });
+
+  it("aborts a whole try block that exceeds its per run budget", async () => {
+    const step = controlstep("t1", "trycatch", {
+      try: {
+        steps: [childstep("f1", "Slow one"), childstep("f2", "Slow two"), childstep("f3", "Slow three")],
+        catch: { steps: [childstep("c1", "Handler step")] },
+        timeout: { runms: 15 },
+      },
+    });
+    const result = await runcontrolstep({
+      step,
+      scopes: rootscope([]),
+      outputs: {},
+      execute: async () => {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        return { ok: true, summary: "slow done" };
+      },
+      now,
+    });
+    expect(result.output.ok).toBe(true);
+    const decision = result.output.details?.control as controlflowdecision;
+    expect(decision.timeouts?.[0]?.scope).toBe("run");
+    expect(result.output.summary).toContain("catch handler ran");
+  });
+
+  it("races the run timeout with the cancelled error class and keeps fast runs intact", async () => {
+    const fast = await applyruntimeout({ budgetms: 500, run: async () => "value" });
+    expect(fast.cancelled).toBe(false);
+    if (!fast.cancelled) expect(fast.value).toBe("value");
+    const slow = await applyruntimeout({
+      budgetms: 5,
+      run: async () => {
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        return "late";
+      },
+    });
+    expect(slow.cancelled).toBe(true);
+    if (slow.cancelled) {
+      expect(slow.error).toBeInstanceOf(cancellederror);
+      expect(slow.error.name).toBe("cancellederror");
+      expect(slow.error.message).toContain("exceeded its reviewed budget of 5 milliseconds");
+    }
+    const guarded = await applytimeout({
+      stepid: "f1",
+      budgetms: 500,
+      run: async () => ({ ok: true, summary: "fast" }),
+    });
+    expect(guarded.aborted).toBe(false);
+    const aborted = await applytimeout({
+      stepid: "f1",
+      budgetms: 5,
+      run: async () => {
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        return { ok: true, summary: "late" };
+      },
+    });
+    expect(aborted.aborted).toBe(true);
+    expect(aborted.output?.details?.errorclass).toBe("timeout");
+    expect(aborted.output?.summary).toContain("exceeded its reviewed budget of 5 milliseconds");
+    expect(aborted.abort?.budget).toBe(5);
+  });
+});
+
+describe("control flow policy", () => {
+  const step = (kind: toolstep["kind"], options: Record<string, unknown>): toolstep => ({
+    id: "w1",
+    kind,
+    summary: "Reviewed control step",
+    risk: actionrisk(kind),
+    options: JSON.stringify(options),
+  });
+  const listbody = {
+    list: "items",
+    item: "item",
+    index: "index",
+    bound: 5,
+    steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+  };
+  const branchbody = {
+    paths: [
+      {
+        name: "fast",
+        when: {
+          left: { ref: "count" },
+          right: { literal: 1 },
+          operator: "equal",
+          result: "isfast",
+          resultkind: "boolean",
+        },
+        steps: [{ id: "b1", kind: "readtext", label: "Fast", target: "h1" }],
+      },
+    ],
+    else: { name: "slow", steps: [] },
+  };
+
+  it("validates the control grammar of every kind before any review", () => {
+    expect(
+      validatestep(
+        step("condition", {
+          condition: { expression: { left: { ref: "ready" }, operator: "not", result: "stop", resultkind: "boolean" } },
+        }),
+        "https://example.com",
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("condition", {
+          condition: {
+            expression: {
+              left: { literal: 1 },
+              right: { literal: 1 },
+              operator: "add",
+              result: "n",
+              resultkind: "number",
+            },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false });
+    expect(validatestep(step("branch", { branch: branchbody }), "https://example.com")).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("branch", {
+          branch: { paths: [{ name: "only", steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }] }] },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false, reason: expect.stringContaining("else path") });
+    expect(validatestep(step("loop", { loop: listbody }), "https://example.com")).toEqual({ allowed: true });
+    expect(validatestep(step("loop", { loop: { ...listbody, item: "items" } }), "https://example.com")).toMatchObject({
+      allowed: false,
+    });
+    expect(
+      validatestep(
+        step("repeatuntil", {
+          repeatuntil: {
+            until: {
+              left: { ref: "count" },
+              right: { literal: 1 },
+              operator: "greaterequal",
+              result: "done",
+              resultkind: "boolean",
+            },
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("whileloop", {
+          while: {
+            while: { left: { literal: true }, operator: "not", result: "go", resultkind: "boolean" },
+            bound: 4,
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("whileloop", {
+          while: {
+            while: { left: { literal: true }, operator: "not", result: "go", resultkind: "boolean" },
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false, reason: expect.stringContaining("safety bound") });
+    expect(
+      validatestep(
+        step("foreach", {
+          foreach: {
+            selector: "li",
+            item: "row",
+            index: "rowindex",
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("parallel", {
+          parallel: {
+            branches: [{ id: "one", steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }] }],
+            join: { strategy: "first", onfail: "continue" },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("parallel", {
+          parallel: {
+            branches: [{ id: "one", steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }] }],
+            join: { strategy: "bogus", onfail: "continue" },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false });
+    expect(
+      validatestep(
+        step("trycatch", {
+          try: {
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+            catch: { steps: [{ id: "c1", kind: "wait", label: "Handle", value: "1" }] },
+            retry: { attempts: 4, backoff: { shape: "exponential", base: 50, jitter: 10 }, retryable: ["timeout"] },
+            timeout: { stepms: 3000 },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toEqual({ allowed: true });
+    expect(
+      validatestep(
+        step("trycatch", {
+          try: {
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+            catch: { steps: [{ id: "c1", kind: "wait", label: "Handle", value: "1" }] },
+            timeout: { stepms: -1 },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false });
+    expect(validatestep(step("loop", {}), "https://example.com")).toMatchObject({ allowed: false });
+  });
+
+  it("refuses control payloads that hide an unreviewed child kind behind their bodies", () => {
+    expect(
+      validatestep(
+        step("loop", {
+          loop: {
+            list: "items",
+            item: "item",
+            index: "index",
+            steps: [{ id: "b1", kind: "explode", label: "Ghost kind" }],
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false, reason: expect.stringContaining("not a reviewed action kind") });
+    expect(
+      validatestep(
+        step("branch", {
+          branch: {
+            paths: [{ name: "only", steps: [{ id: "b1", kind: "explode", label: "Ghost kind" }] }],
+            else: { name: "else", steps: [] },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false, reason: expect.stringContaining("not a reviewed action kind") });
+    expect(
+      validatestep(
+        step("trycatch", {
+          try: {
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+            catch: { steps: [{ id: "c1", kind: "explode", label: "Ghost kind" }] },
+          },
+        }),
+        "https://example.com",
+      ),
+    ).toMatchObject({ allowed: false, reason: expect.stringContaining("not a reviewed action kind") });
+  });
+
+  it("grades a composed workflow with control steps by its worst child kind", () => {
+    const readonly = composeworkflow({
+      name: "reader",
+      version: 1,
+      origins: ["https://example.com"],
+      steps: [
+        controlstep("l1", "loop", {
+          loop: { ...listbody, steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }] },
+        }),
+      ] as never,
+      now,
+      kindallowed,
+      riskof,
+    });
+    expect(readonly.risk).toBe("interaction");
+    const mutating = composeworkflow({
+      name: "writer",
+      version: 1,
+      origins: ["https://example.com"],
+      steps: [
+        controlstep("b1", "branch", {
+          branch: {
+            paths: [{ name: "only", steps: [{ id: "c1", kind: "click", label: "Click", target: "#submit" }] }],
+            else: { name: "else", steps: [] },
+          },
+        }),
+      ] as never,
+      now,
+      kindallowed,
+      riskof,
+    });
+    expect(mutating.risk).toBe("sensitive");
+    expect(() =>
+      composeworkflow({
+        name: "ghost",
+        version: 1,
+        origins: ["https://example.com"],
+        steps: [controlstep("l1", "loop", { loop: { list: "items", item: "item", index: "index" } })] as never,
+        now,
+        kindallowed,
+        riskof,
+      }),
+    ).toThrow("loop step needs");
+    expect(() =>
+      composeworkflow({
+        name: "ghost",
+        version: 1,
+        origins: ["https://example.com"],
+        steps: [
+          controlstep("l1", "loop", { loop: { ...listbody, steps: [{ id: "b1", kind: "explode", label: "Ghost" }] } }),
+        ] as never,
+        now,
+        kindallowed,
+        riskof,
+      }),
+    ).toThrow("not a reviewed action kind");
+  });
+
+  it("projects control steps for dry runs only when every child step grades read", () => {
+    expect(
+      dryrunprojection(
+        controlstep("c1", "condition", {
+          condition: { expression: { left: { ref: "ready" }, operator: "not", result: "stop", resultkind: "boolean" } },
+        }),
+      ),
+    ).toContain("no page side effect");
+    expect(
+      dryrunprojection(
+        controlstep("l1", "loop", {
+          loop: { ...listbody, steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }] },
+        }),
+      ),
+    ).toContain("safety bound");
+    expect(
+      dryrunprojection(
+        controlstep("p1", "parallel", {
+          parallel: {
+            branches: [{ id: "one", steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }] }],
+            join: { strategy: "first", onfail: "continue" },
+          },
+        }),
+      ),
+    ).toContain("join their outcomes");
+    expect(
+      dryrunprojection(
+        controlstep("t1", "trycatch", {
+          try: {
+            steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+            catch: { steps: [{ id: "c1", kind: "wait", label: "Handle", value: "1" }] },
+          },
+        }),
+      ),
+    ).toContain("catch handler");
+    expect(
+      dryrunprojection(
+        controlstep("l1", "loop", {
+          loop: { ...listbody, steps: [{ id: "b1", kind: "click", label: "Click", target: "#submit" }] },
+        }),
+      ),
+    ).toBeUndefined();
+    expect(
+      dryrunprojection(
+        controlstep("t1", "trycatch", {
+          try: {
+            steps: [{ id: "b1", kind: "click", label: "Click", target: "#submit" }],
+            catch: { steps: [{ id: "c1", kind: "wait", label: "Handle", value: "1" }] },
+          },
+        }),
+      ),
+    ).toBeUndefined();
+  });
+});
+
+describe("control flow inside the run loop", () => {
+  it("runs a control step as a workflow step adopting its child runlog and merged scopes", async () => {
+    const record = composeworkflow({
+      name: "controlled",
+      version: 1,
+      origins: ["https://example.com"],
+      steps: [
+        controlstep("l1", "loop", {
+          loop: {
+            list: "items",
+            item: "item",
+            index: "index",
+            bound: 4,
+            steps: [
+              workflowstepof({
+                id: "b1",
+                kind: "readtext",
+                label: "Read the row",
+                target: 'li[data-id="${item}"]',
+              }) as workflowstep,
+            ],
+          },
+        }),
+        { id: "s2", kind: "wait", label: "Final wait", value: "10" },
+      ] as never,
+      now,
+      kindallowed,
+      riskof,
+    });
+    const seen: string[] = [];
+    const baseexecute = async (dispatched: workflowstep): Promise<{ ok: boolean; summary: string }> => {
+      seen.push(`${dispatched.id}:${dispatched.target ?? ""}`);
+      return { ok: true, summary: "ok" };
+    };
+    const result = await runworkflow({
+      record,
+      run: newworkflowrun({ id: "run1", workflowid: record.id, now }),
+      scopes: rootscope([{ name: "items", kind: "list", value: ["x", "y"] }]),
+      execute: controlexecutor(baseexecute) as never,
+      now,
+      gates: { sessionactive: true, planapproved: true, origingranted: () => true },
+    });
+    expect(result.run.state).toBe("done");
+    expect(result.run.cursor).toBe(2);
+    expect(seen).toEqual(['b1:li[data-id="x"]', 'b1:li[data-id="y"]', "s2:"]);
+    expect(result.log.map((entry) => entry.stepid)).toEqual(["b1", "l1", "b1", "l1", "l1", "s2"]);
+    expect(result.log.every((entry) => entry.state === "done")).toBe(true);
+  });
+
+  it("fails the run at a failing control step without advancing the checkpoint", async () => {
+    const record = composeworkflow({
+      name: "failing",
+      version: 1,
+      origins: ["https://example.com"],
+      steps: [
+        controlstep("l1", "loop", {
+          loop: {
+            list: "items",
+            item: "item",
+            index: "index",
+            steps: [{ id: "b1", kind: "wait", label: "Body", value: "10" }],
+          },
+        }),
+        { id: "s2", kind: "wait", label: "Never reached", value: "10" },
+      ] as never,
+      now,
+      kindallowed,
+      riskof,
+    });
+    const result = await runworkflow({
+      record,
+      run: newworkflowrun({ id: "run1", workflowid: record.id, now }),
+      scopes: rootscope([{ name: "items", kind: "list", value: ["x"] }]),
+      execute: controlexecutor(async () => ({ ok: false, summary: "the row refused" })) as never,
+      now,
+      gates: { sessionactive: true, planapproved: true, origingranted: () => true },
+    });
+    expect(result.run.state).toBe("failed");
+    expect(result.run.cursor).toBe(0);
+    expect(result.run.failreason).toContain("failed at iteration 1");
+  });
+
+  it("keeps control steps inside the session, plan and origin gates", async () => {
+    const record = composeworkflow({
+      name: "gated",
+      version: 1,
+      origins: ["https://example.com"],
+      steps: [
+        controlstep("c1", "condition", {
+          condition: {
+            expression: { left: { literal: true }, operator: "not", result: "stop", resultkind: "boolean" },
+          },
+        }),
+      ] as never,
+      now,
+      kindallowed,
+      riskof,
+    });
+    const run = newworkflowrun({ workflowid: record.id, now });
+    await expect(
+      runworkflow({
+        record,
+        run,
+        execute: controlexecutor(async () => ({ ok: true, summary: "x" })) as never,
+        now,
+        gates: { sessionactive: false, planapproved: true, origingranted: () => true },
+      }),
+    ).rejects.toThrow("approved session");
+    await expect(
+      runworkflow({
+        record,
+        run,
+        execute: controlexecutor(async () => ({ ok: true, summary: "x" })) as never,
+        now,
+        gates: { sessionactive: true, planapproved: false, origingranted: () => true },
+      }),
+    ).rejects.toThrow("approved plan");
+    await expect(
+      runworkflow({
+        record,
+        run,
+        execute: controlexecutor(async () => ({ ok: true, summary: "x" })) as never,
+        now,
+        gates: { sessionactive: true, planapproved: true, origingranted: () => false },
+      }),
+    ).rejects.toThrow("outside the session grants");
+  });
+
+  it("runs one control step in isolation outside the run loop", async () => {
+    const step = controlstep("c1", "condition", {
+      condition: {
+        expression: {
+          left: { ref: "count" },
+          right: { literal: 3 },
+          operator: "greaterequal",
+          result: "done",
+          resultkind: "boolean",
+        },
+      },
+    });
+    const executed = await runstep({
+      step,
+      scopes: rootscope([{ name: "count", kind: "number", value: 5 }]),
+      outputs: {},
+      execute: controlexecutor(async () => ({ ok: true, summary: "never" })) as never,
+      now,
+    });
+    expect(executed.output.ok).toBe(true);
+    expect(executed.output.summary).toContain("holds over the extracted values");
+    expect(resolvevariable(executed.scopes, "done")?.value).toBe(true);
+    expect(executed.log.checkpoint).toBe(true);
+  });
+});
+
+describe("control flow protocol", () => {
+  it("carries the control grammar summaries through a workflow proposal", () => {
+    const proposal = parseworkflowproposal(
+      {
+        version: protocolversion,
+        workflow: {
+          name: "controlled",
+          version: 1,
+          origins: ["https://example.com"],
+          steps: [
+            controlstep("c1", "condition", {
+              condition: {
+                expression: { left: { literal: true }, operator: "not", result: "stop", resultkind: "boolean" },
+              },
+            }),
+            controlstep("l1", "loop", {
+              loop: {
+                list: "items",
+                item: "item",
+                index: "index",
+                bound: 12,
+                steps: [{ id: "b1", kind: "readtext", label: "Read", target: "h1" }],
+              },
+            }),
+            controlstep("t1", "trycatch", {
+              try: {
+                steps: [{ id: "f1", kind: "readtext", label: "Read", target: "p" }],
+                catch: { steps: [{ id: "c1", kind: "wait", label: "Handle", value: "1" }] },
+              },
+            }),
+            { id: "s2", kind: "wait", label: "Plain wait", value: "5" },
+          ],
+          blocks: [],
+        },
+      },
+      "https://example.com",
+      ["https://example.com"],
+    );
+    expect(proposal.control).toHaveLength(3);
+    expect(proposal.control?.[0]).toMatchObject({ stepid: "c1", summary: { kind: "condition" } });
+    expect(proposal.control?.[1]?.summary).toMatchObject({ kind: "loop", bound: 12 });
+    expect(proposal.control?.[2]?.summary).toMatchObject({ kind: "trycatch" });
+    const plain = parseworkflowproposal(
+      {
+        version: protocolversion,
+        workflow: {
+          name: "plain",
+          version: 1,
+          origins: ["https://example.com"],
+          steps: [{ id: "s1", kind: "wait", label: "Wait", value: "5" }],
+        },
+      },
+      "https://example.com",
+    );
+    expect(plain.control).toBeUndefined();
+  });
+
+  it("carries branch outcomes, loop counters, retries and timeout aborts through the outcome envelope", () => {
+    const run = { ...newworkflowrun({ id: "run1", workflowid: "wf1", now }), state: "done" as const };
+    const decision: controlflowdecision = {
+      runid: "run1",
+      stepid: "l1",
+      kind: "loop",
+      at: now,
+      loops: [{ stepid: "l1", path: "l1[0]", iteration: 0, ok: true, at: now }],
+    };
+    const entries: runlogentry[] = [
+      {
+        stepid: "l1",
+        label: "The loop step",
+        state: "done",
+        startedat: now,
+        duration: 9,
+        summary: "The loop ran 1 iteration.",
+        checkpoint: true,
+        details: { control: decision },
+      },
+      { stepid: "s2", label: "Plain", state: "done", startedat: now + 5, duration: 1, summary: "ok" },
+    ];
+    const outcome = workflowoutcome({ run, entries });
+    expect(outcome.steps[0]?.control).toEqual(decision);
+    expect(outcome.steps[1]?.control).toBeUndefined();
+    const single = workflowoutcome({ run, entries, stepid: "l1" });
+    expect(single.steps).toHaveLength(1);
+    expect(single.steps[0]?.control?.kind).toBe("loop");
+    const report = workflowreport({ workflows: [], runs: [run], templates: [], control: [decision] });
+    expect(report.control).toEqual([decision]);
+    expect(workflowreport({ workflows: [], runs: [], templates: [] }).control).toEqual([]);
+  });
+
+  it("reports timeout aborts and retry exhaustion distinctly in the response envelope", () => {
+    const planapproved: agentplan = { ...plan, state: "approved" };
+    const timeout: timeoutabort = { stepid: "f1", budget: 5000, scope: "step", at: now };
+    const response = JSON.parse(
+      outcomeresponse({
+        outcome: { stepid: "w1", ok: false, summary: "The run failed after retries.", at: now },
+        plan: planapproved,
+        workflow: {
+          runid: "run1",
+          state: "failed",
+          produced: ["count"],
+          consumed: ["items"],
+          timeout,
+          retry: { stepid: "f1", attempts: 3, exhausted: true },
+        },
+      }),
+    ) as { workflow?: { timeout?: timeoutabort; retry?: { attempts: number; exhausted: boolean } } };
+    expect(response.workflow?.timeout).toEqual(timeout);
+    expect(response.workflow?.retry).toEqual({ stepid: "f1", attempts: 3, exhausted: true });
+    const clean = JSON.parse(
+      outcomeresponse({
+        outcome: { stepid: "w1", ok: true, summary: "done", at: now },
+        plan: planapproved,
+        workflow: { runid: "run2", state: "done", produced: [], consumed: [] },
+      }),
+    ) as { workflow?: { timeout?: unknown; retry?: unknown } };
+    expect(clean.workflow?.timeout).toBeUndefined();
+    expect(clean.workflow?.retry).toBeUndefined();
+  });
+});
+
+describe("control flow memory and progress", () => {
+  it("stores branch, loop, retry, timeout and join decisions and returns the branch history of a workflow", async () => {
+    const store = new sessionmemory(new fakeadapter());
+    const decisions: controlflowdecision[] = [
+      {
+        runid: "run1",
+        stepid: "b1",
+        kind: "branch",
+        at: now,
+        branch: { stepid: "b1", path: "fast", reason: "The condition of the path fast holds.", at: now },
+      },
+      {
+        runid: "run1",
+        stepid: "l1",
+        kind: "loop",
+        at: now + 1,
+        loops: [{ stepid: "l1", path: "l1[0]", iteration: 0, ok: true, at: now + 1 }],
+      },
+      {
+        runid: "run1",
+        stepid: "t1",
+        kind: "retry",
+        at: now + 2,
+        retries: [{ stepid: "f1", attempt: 2, delay: 20, errorclass: "pageunresponsive", at: now + 2 }],
+      },
+      {
+        runid: "run1",
+        stepid: "t1",
+        kind: "timeout",
+        at: now + 3,
+        timeouts: [{ stepid: "f1", budget: 5000, scope: "step", at: now + 3 }],
+      },
+      {
+        runid: "run1",
+        stepid: "p1",
+        kind: "join",
+        at: now + 4,
+        join: { stepid: "p1", strategy: "last", conflicts: ["shared"], merged: ["shared"], at: now + 4 },
+      },
+    ];
+    for (const decision of decisions) await store.addcontroldecision("run1", decision);
+    expect((await store.listcontroldecisions("run1")).map((decision) => decision.kind)).toEqual([
+      "branch",
+      "loop",
+      "retry",
+      "timeout",
+      "join",
+    ]);
+    expect(await store.listcontroldecisions("missing")).toEqual([]);
+    const retryattempt: retryattempt = { stepid: "f1", attempt: 2, delay: 20, errorclass: "pageunresponsive", at: now };
+    expect(retryattempt.delay).toBe(20);
+    await store.setworkflowrun({
+      id: "run1",
+      workflowid: "wf1",
+      state: "done",
+      cursor: 1,
+      startedat: now,
+      endedat: now + 5,
+    });
+    await store.setworkflowrun({
+      id: "run2",
+      workflowid: "wf1",
+      state: "done",
+      cursor: 1,
+      startedat: now + 10,
+      endedat: now + 15,
+    });
+    await store.setworkflowrun({
+      id: "run3",
+      workflowid: "wf2",
+      state: "done",
+      cursor: 1,
+      startedat: now + 20,
+      endedat: now + 25,
+    });
+    await store.addcontroldecision("run2", {
+      runid: "run2",
+      stepid: "b1",
+      kind: "branch",
+      at: now + 11,
+      branch: { stepid: "b1", path: "slow", reason: "No path condition held and the else path ran.", at: now + 11 },
+    });
+    const history = await store.getbranchhistory("wf1");
+    expect(history.map((outcome) => outcome.path)).toEqual(["fast", "slow"]);
+    expect(await store.getbranchhistory("wf2")).toEqual([]);
+  });
+
+  it("counts loop iterations toward the user defined denominator in progress", () => {
+    let progress = recordworkflow(
+      undefined,
+      "run",
+      "w1",
+      {
+        family: "control",
+        detail: "The control flow steps ran their loops",
+        runid: "run1",
+        iterations: 7,
+        denominator: 10,
+      },
+      now,
+    );
+    const evidence = workflowevidences(progress, "run", "w1");
+    expect(evidence[0]?.family).toBe("control");
+    expect(evidence[0]?.iterations).toBe(7);
+    expect(evidence[0]?.denominator).toBe(10);
+    expect((progress.outcomes ?? [])[0]?.summary).toContain("7 iterations");
+    expect((progress.outcomes ?? [])[0]?.summary).toContain("denominator 10");
+    expect(loopshare(7, 10)).toBe(0.7);
+    expect(loopshare(12, 10)).toBe(1);
+    expect(loopshare(3, 0)).toBe(0);
+    expect(workflowevidences(progress, "other", "w1")).toEqual([]);
+  });
+});