labcode 0.5.0__tar.gz → 0.7.0__tar.gz

{labcode-0.5.0 → labcode-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labcode
-Version: 0.5.0
+Version: 0.7.0
 Summary: labcode -- a dialect wrapper over the Object-Flow Programming Language toolchain
 Author-email: Kazunari Kaizu <kwaizu@gmail.com>
 License-Expression: MIT
@@ -21,8 +21,8 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ofplang-validate<0.3,>=0.2
-Requires-Dist: ofplang-schedule<0.10,>=0.9
-Requires-Dist: ofplang-run<0.9,>=0.8
+Requires-Dist: ofplang-schedule<0.11,>=0.9
+Requires-Dist: ofplang-run<0.12,>=0.11
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: opentelemetry-sdk>=1.20; extra == "test"
@@ -145,9 +145,29 @@ lc run <workflow> --env <env>
     [--seconds-per-tick S] [--op-timeout S | --no-op-timeout] [--no-probe]
     [--max-transport-legs N] [--ignore-resources] [--trace] [--mission-id ID]
     [--object-ids seeded|real]
+
+lc run --jobs <run doc> --env <env> [--on-job-failure continue|stop] [...]
 ```
 
 - `<workflow>` — the portable v0 workflow: *what* happens.
+- `--jobs RUNDOC` — run **several jobs together** in one laboratory (schedule SPEC
+  §6.11) in place of the single `<workflow>`. The run document names each job — an `id`,
+  its workflow, its own boundary, and when it may start — plus what the laboratory's own
+  stocks hold to begin with and which spots it is already holding. They are planned
+  *together*, so they compete for the same machines and share a refill neither needs
+  alone. Each job's workflow goes through both front doors separately and a rejection
+  names the job it came from; a boundary belongs to a job, so `--boundary` is not used
+  with `--jobs`.
+  🔴 Object identities are minted **per job**: two jobs of one workflow bind the same
+  port names and render the same node paths, so a reproducible generator keyed on those
+  alone would give one job's plate the other's `_id`. `--trace` records the job on every
+  operation (`ofp.job`) for the same reason — the node alone does not say whose work it
+  was. A run of a single workflow names no job and is recorded exactly as it always was.
+- `--on-job-failure continue|stop` — what one job's failure does to the rest of a
+  `--jobs` run. `continue` (the default) stops that job alone and lets the others
+  finish — which is why they were planned together — while `stop` stops the whole run.
+  A stopped job's plate stays where it is, and the plan is made around it rather than
+  onto it. A single workflow is a single job, so this makes no difference to it.
 - `--env` (required) — the labcode environment: the execution environment (spec §5) plus
   the `x-labcode` extension saying *how* each operation is carried out.
 - `--boundary DOC` — the whole-workflow I/O as one document: a `boundary:` mapping with a

{labcode-0.5.0 → labcode-0.7.0}/README.md

@@ -101,9 +101,29 @@ lc run <workflow> --env <env>
     [--seconds-per-tick S] [--op-timeout S | --no-op-timeout] [--no-probe]
     [--max-transport-legs N] [--ignore-resources] [--trace] [--mission-id ID]
     [--object-ids seeded|real]
+
+lc run --jobs <run doc> --env <env> [--on-job-failure continue|stop] [...]
 ```
 
 - `<workflow>` — the portable v0 workflow: *what* happens.
+- `--jobs RUNDOC` — run **several jobs together** in one laboratory (schedule SPEC
+  §6.11) in place of the single `<workflow>`. The run document names each job — an `id`,
+  its workflow, its own boundary, and when it may start — plus what the laboratory's own
+  stocks hold to begin with and which spots it is already holding. They are planned
+  *together*, so they compete for the same machines and share a refill neither needs
+  alone. Each job's workflow goes through both front doors separately and a rejection
+  names the job it came from; a boundary belongs to a job, so `--boundary` is not used
+  with `--jobs`.
+  🔴 Object identities are minted **per job**: two jobs of one workflow bind the same
+  port names and render the same node paths, so a reproducible generator keyed on those
+  alone would give one job's plate the other's `_id`. `--trace` records the job on every
+  operation (`ofp.job`) for the same reason — the node alone does not say whose work it
+  was. A run of a single workflow names no job and is recorded exactly as it always was.
+- `--on-job-failure continue|stop` — what one job's failure does to the rest of a
+  `--jobs` run. `continue` (the default) stops that job alone and lets the others
+  finish — which is why they were planned together — while `stop` stops the whole run.
+  A stopped job's plate stays where it is, and the plan is made around it rather than
+  onto it. A single workflow is a single job, so this makes no difference to it.
 - `--env` (required) — the labcode environment: the execution environment (spec §5) plus
   the `x-labcode` extension saying *how* each operation is carried out.
 - `--boundary DOC` — the whole-workflow I/O as one document: a `boundary:` mapping with a

{labcode-0.5.0 → labcode-0.7.0}/labcode/backend.py

@@ -71,6 +71,7 @@ from labcode.probe import (
 )
 from labcode.record import (
     ATTR_DEVICE,
+    ATTR_JOB,
     ATTR_MODE,
     ATTR_NODE,
     ATTR_OBJECT_ID,
@@ -408,7 +409,8 @@ class LabcodeBackend(SubprocessBackend):
             self._record_objects.pop(key, None)
             self._recorder.op_finished(key, error_type=RUN_STOPPED, message="the run ended first")
 
-    def _resolve_model(self, process, mode, inputs, output_schema, definition, node=None):
+    def _resolve_model(self, process, mode, inputs, output_schema, definition,
+                       node=None, job=None):
         """The value model `_complete` calls at completion: merge the script's *partial*
         outputs onto the defaults (§1.2), then stamp Object identities (`_id`).
 
@@ -416,13 +418,20 @@ class LabcodeBackend(SubprocessBackend):
         defaults); the script's returned values override it. A returned name outside
         `output_schema` is a runtime failure. `stamp_object_ids` then mints ``_id`` for a
         created Object and carries it for a mapped one (keyed by `node`, the workflow
-        provenance). A timed op (no child) or a child error is handled as in the base
-        backend."""
+        provenance, **and by `job`** -- two jobs of one workflow render the same node
+        path, so the node alone would mint one identity for two plates). A timed op (no
+        child) or a child error is handled as in the base backend.
+
+        🔴 Both halves arrive here rather than at dispatch because this is where an
+        identity is *made*: the runner offers provenance to a model that declares it
+        (`ofplang-run` >= 0.11), and the simulator carries it on the operation from the
+        dispatch that started it."""
         pending = self._pending
         if not isinstance(pending, dict):  # the _TIMED sentinel: no child ran
             outputs = default_device_model(process, mode, inputs, output_schema, definition)
             return stamp_object_ids(
-                outputs, definition, inputs or {}, node, self._id_gen, output_schema
+                outputs, definition, inputs or {}, node, self._id_gen, output_schema,
+                job=job,
             )
         if "error" in pending:
             err = pending["error"]
@@ -438,7 +447,8 @@ class LabcodeBackend(SubprocessBackend):
             )
         base = default_device_model(process, mode, inputs, output_schema, definition)
         return stamp_object_ids(
-            {**base, **raw}, definition, inputs or {}, node, self._id_gen, output_schema
+            {**base, **raw}, definition, inputs or {}, node, self._id_gen, output_schema,
+            job=job,
         )
 
     def advance(self, until: int) -> int:
@@ -484,11 +494,15 @@ class LabcodeBackend(SubprocessBackend):
 
     def dispatch_processing(
         self, process, mode, duration=None, output_schema=None, inputs=None,
-        definition=None, node=None,
+        definition=None, node=None, job=None,
     ) -> str:
         attributes: dict[str, Any] = {ATTR_PROCESS: str(process), ATTR_MODE: str(mode)}
         if node:
             attributes[ATTR_NODE] = "/".join(str(step) for step in node)
+        # Recorded beside the node, and absent where the run names no job: a record of a
+        # single workflow says exactly what it always said.
+        if job:
+            attributes[ATTR_JOB] = str(job)
         key = self._begin_record(
             f"{SPAN_PROCESS_PREFIX}{process}", attributes,
             duration=duration, identities=_object_ids(inputs),
@@ -497,17 +511,22 @@ class LabcodeBackend(SubprocessBackend):
             with self._recorder.op_active(key):
                 uuid = super().dispatch_processing(
                     process, mode, duration=duration, output_schema=output_schema,
-                    inputs=inputs, definition=definition, node=node,
+                    inputs=inputs, definition=definition, node=node, job=job,
                 )
         except BaseException as exc:
             self._refused(key, exc)
             raise
         return self._dispatched(key, uuid)
 
-    def dispatch_transport(self, transporter, from_spot, to_spot, duration=None, view=None) -> str:
+    def dispatch_transport(self, transporter, from_spot, to_spot, duration=None,
+                           view=None, job=None) -> str:
         attributes: dict[str, Any] = {ATTR_SPOT_FROM: str(from_spot), ATTR_SPOT_TO: str(to_spot)}
         if transporter is not None:
             attributes[ATTR_TRANSPORTER] = str(transporter)
+        # Two jobs of one workflow can move between the same pair of spots, so the route
+        # alone does not say whose plate this was.
+        if job:
+            attributes[ATTR_JOB] = str(job)
         key = self._begin_record(
             SPAN_TRANSPORT, attributes, duration=duration, identities=_object_ids(view)
         )
@@ -516,7 +535,7 @@ class LabcodeBackend(SubprocessBackend):
             # starts and the transport's own child land under this operation.
             with self._recorder.op_active(key):
                 uuid = super().dispatch_transport(
-                    transporter, from_spot, to_spot, duration=duration, view=view
+                    transporter, from_spot, to_spot, duration=duration, view=view, job=job
                 )
                 code = self._transport_resolver(transporter, from_spot, to_spot)
                 if code is not None:

{labcode-0.5.0 → labcode-0.7.0}/labcode/objectid.py

@@ -121,17 +121,31 @@ def entry_object_inputs(workflow: dict) -> dict[str, str]:
     return result
 
 
+def _key(job: str | None, rest: str) -> str:
+    """A mint key, prefixed by the job where there is one (SPEC §6.11).
+
+    🔴 **Only where there is one.** Two jobs of one workflow bind the same port names
+    and render the same node paths, so without the job a reproducible generator gives
+    one job's plate the other's identity -- silently, and the same way every run. But a
+    run of a *single* workflow names no job, and prefixing there would change every id
+    labcode has ever minted for one: the checked-in example observations are that
+    invariant, and a run that was reproducible must stay reproducible in the same way.
+    """
+    return f"job:{job}:{rest}" if job else rest
+
+
 def inject_boundary_ids(
-    boundary: dict | None, workflow: dict, id_gen: IdGenerator
+    boundary: dict | None, workflow: dict, id_gen: IdGenerator, job: str | None = None
 ) -> dict | None:
     """Return `boundary` with each Object input's view carrying an ``_id``.
 
     For every Object-bearing entry input, ensure ``boundary.inputs[port].view`` exists,
     fill any declared view field the user omitted with a typed default, and mint ``_id``
-    (keyed by the port) unless one is already present -- so a result boundary fed back in
-    round-trips its ids. `workflow` must be the ``_id``-injected document (so the view
-    schema includes ``_id``). Returns `boundary` unchanged when it is None or has no
-    Object inputs. Mutates a deep copy, not the caller's dict."""
+    (keyed by the port, and by `job` where the run names one) unless one is already
+    present -- so a result boundary fed back in round-trips its ids. `workflow` must be
+    the ``_id``-injected document (so the view schema includes ``_id``). Returns
+    `boundary` unchanged when it is None or has no Object inputs. Mutates a deep copy,
+    not the caller's dict."""
     obj_inputs = entry_object_inputs(workflow)
     if boundary is None or not obj_inputs:
         return boundary
@@ -149,7 +163,7 @@ def inject_boundary_ids(
             if field != RESERVED_ID and field not in view:
                 view[field] = _default_field(descriptor)
         if not view.get(RESERVED_ID):
-            view[RESERVED_ID] = id_gen.new_id(f"boundary:{port}")
+            view[RESERVED_ID] = id_gen.new_id(_key(job, f"boundary:{port}"))
         desc["view"] = view
     return out
 
@@ -191,6 +205,7 @@ def stamp_object_ids(
     node,
     id_gen: IdGenerator,
     output_schema: dict | None = None,
+    job: str | None = None,
 ) -> dict:
     """Stamp ``_id`` onto a process op's produced Object output views (mutates `outputs`).
 
@@ -206,10 +221,12 @@ def stamp_object_ids(
       returned the port explicitly (overwriting the carried view).
     * A **created** Object output (``objects.create``) whose ``_id`` is empty/absent gets
       a freshly minted id, keyed by this node instance + port -- so two creates of the
-      same process (different nodes) get distinct, reproducible ids.
+      same process (different nodes) get distinct, reproducible ids -- **and by the job
+      where the run names one**, since two jobs of one workflow render the same node
+      path and would otherwise mint one identity for two plates.
 
-    `node` is the workflow provenance (a node-path tuple, or None); `inputs` are the op's
-    input views."""
+    `node` is the workflow provenance (a node-path tuple, or None) and `job` which job of
+    a joint run this is (or None); `inputs` are the op's input views."""
     created, mapped = _object_output_ports(definition)
     for port in (*mapped, *created):
         if not _declares_id(output_schema, port):
@@ -227,5 +244,5 @@ def stamp_object_ids(
     for port in created:
         view = outputs.get(port)
         if isinstance(view, dict) and not view.get(RESERVED_ID):
-            view[RESERVED_ID] = id_gen.new_id(f"node:{node_key}:{port}")
+            view[RESERVED_ID] = id_gen.new_id(_key(job, f"node:{node_key}:{port}"))
     return outputs

{labcode-0.5.0 → labcode-0.7.0}/labcode/record.py

@@ -51,6 +51,11 @@ ATTR_MISSION = "mission.id"
 #: Where in the workflow this operation came from, and what it was assigned to. These are
 #: *pointers* into the workflow and environment documents, not copies of them.
 ATTR_NODE = "ofp.node"
+#: Which job of a joint run (`lc run --jobs`, schedule SPEC §6.11) the operation belongs
+#: to. Absent on a run of a single workflow, which names no job. Recorded beside the node
+#: because the node alone does not identify the work: two jobs of one workflow render the
+#: same node path and can move between the same pair of spots.
+ATTR_JOB = "ofp.job"
 ATTR_PROCESS = "ofp.process"
 ATTR_MODE = "ofp.mode"
 ATTR_SPOT_FROM = "ofp.spot.from"

{labcode-0.5.0 → labcode-0.7.0}/labcode/run_cli.py

@@ -28,6 +28,7 @@ import argparse
 import contextlib
 import sys
 from collections.abc import Sequence
+from dataclasses import replace
 from pathlib import Path
 
 import yaml
@@ -37,6 +38,7 @@ from ofplang.run.runner import (
     ContractSyntaxError,
     RunnerError,
     load_document,
+    parse_run_document,
     serialize_document,
 )
 from ofplang.run.simulator import SimulatorError
@@ -57,9 +59,28 @@ def _build_parser() -> argparse.ArgumentParser:
         prog="lc run",
         description="Run an ofplang v0 workflow on the labcode backend (env x-labcode scripts).",
     )
-    p.add_argument("workflow", metavar="WORKFLOW", help="ofplang v0 workflow YAML")
+    p.add_argument(
+        "workflow", metavar="WORKFLOW", nargs="?",
+        help="ofplang v0 workflow YAML (omit when --jobs names a run document)",
+    )
+    p.add_argument(
+        "--jobs", metavar="RUNDOC",
+        help="run document (YAML): a `jobs:` list naming each job's id, workflow, "
+        "boundary and release, plus the laboratory's own starting `inventories` and "
+        "`occupied` spots. The jobs are planned TOGETHER (schedule SPEC §6.11), so they "
+        "compete for the same machines and share the refills neither needs alone. Each "
+        "job's Object identities are minted per job, so two jobs of one workflow are "
+        "told apart in the record and in every `_id`",
+    )
     p.add_argument("--env", required=True, metavar="ENV", help="execution environment YAML (§5)")
     p.add_argument("--boundary", metavar="DOC", help="run boundary document (§6.8 / value layer)")
+    p.add_argument(
+        "--on-job-failure", choices=("continue", "stop"), default="continue", metavar="POLICY",
+        help="what one job's failure does to the rest of a --jobs run (§6.11): "
+        "`continue` (the default) stops that job alone and lets the others finish -- "
+        "which is why they were planned together -- while `stop` stops the whole run. A "
+        "single workflow is a single job, so this makes no difference to it",
+    )
     p.add_argument("--seed", type=int, metavar="N", help="scheduler random seed")
     p.add_argument(
         "--margin", type=int, default=None, metavar="M",
@@ -210,8 +231,24 @@ def main(argv: Sequence[str] | None = None) -> int:
 
     args = _build_parser().parse_args(argv)
 
-    for label, path in (("workflow", args.workflow), ("environment", args.env)):
-        if not Path(path).is_file():
+    # One form or the other: a workflow, or a run document naming several jobs. A
+    # boundary belongs to a job, so a roster carries one per job rather than one for the
+    # run -- passing both would be two answers to the same question.
+    if bool(args.workflow) == bool(args.jobs):
+        print("lc run: give either a WORKFLOW or --jobs RUNDOC, not both", file=sys.stderr)
+        return EXIT_USAGE
+    if args.jobs and args.boundary:
+        print(
+            "lc run: --boundary applies to a single workflow; with --jobs each job "
+            "carries its own boundary in the run document",
+            file=sys.stderr,
+        )
+        return EXIT_USAGE
+
+    for label, path in (
+        ("workflow", args.workflow), ("run document", args.jobs), ("environment", args.env)
+    ):
+        if path and not Path(path).is_file():
             print(f"lc run: {label} not found: {path!r}", file=sys.stderr)
             return EXIT_USAGE
 
@@ -242,28 +279,65 @@ def main(argv: Sequence[str] | None = None) -> int:
     if args.mission_id and not args.trace:
         print("lc run: warning: --mission-id is only recorded with --trace", file=sys.stderr)
 
-    # Shared workflow front door (ofplang-validate + capability gate; validate skippable).
-    fd = front_door_check(args.workflow, validate=not args.no_validate)
-    if not fd.ok:
-        _print_front_door(fd)
-        return EXIT_USAGE
-
-    # labcode dialect front door: validate the env x-labcode extension (P5) over the
-    # workflow (for (1)/(2) exclusivity) and the environment. Warnings are printed but do
-    # not block; errors are a usage error. Use the *expanded* workflow the shared front
-    # door already resolved (`fd.document`), so `$import` is applied once, no second read
-    # happens, and imported types/ops are visible to the dialect check and `_id` setup.
-    workflow_doc = fd.document or {}
     env_doc, err = _read_document(args.env, "environment")
     if err is not None:
         return err
-    dialect = validate_dialect(workflow_doc, env_doc or {})
-    for warning in dialect.warnings:
-        print(f"lc run: warning: {warning}", file=sys.stderr)
-    if not dialect.ok:
-        for error in dialect.errors:
-            print(f"lc run: x-labcode error: {error}", file=sys.stderr)
-        return EXIT_USAGE
+
+    run_doc = None
+    if args.jobs:
+        doc, err = _read_document(args.jobs, "run document")
+        if err is not None:
+            return err
+        try:
+            run_doc = parse_run_document(doc or {}, Path(args.jobs).parent)
+        except RunnerError as exc:
+            print(f"lc run: {exc}", file=sys.stderr)
+            return EXIT_USAGE
+
+    # Both front doors, per job. The shared one (ofplang-validate + capability gate) and
+    # the labcode dialect one (the env's x-labcode extension read over *this* workflow,
+    # for (1)/(2) exclusivity and the no-op warnings) are about a workflow, so a roster
+    # goes through them one job at a time -- and the failing job is named, since several
+    # jobs commonly run the same file and a diagnostic that does not say which job it
+    # came from sends the reader to the wrong place.
+    #
+    # The *expanded* workflow the shared front door resolved (`fd.document`) is what goes
+    # on: `$import` is applied once, no second read happens, and imported types / ops are
+    # visible to the dialect check and to the `_id` setup.
+    def _doors(workflow, where: str):
+        fd = front_door_check(workflow, validate=not args.no_validate)
+        if not fd.ok:
+            if where:
+                print(f"lc run: {where}:", file=sys.stderr)
+            _print_front_door(fd)
+            return None
+        expanded = fd.document or {}
+        dialect = validate_dialect(expanded, env_doc or {})
+        prefix = f"{where}: " if where else ""
+        for warning in dialect.warnings:
+            print(f"lc run: warning: {prefix}{warning}", file=sys.stderr)
+        if not dialect.ok:
+            for error in dialect.errors:
+                print(f"lc run: x-labcode error: {prefix}{error}", file=sys.stderr)
+            return None
+        return expanded
+
+    target: object
+    if run_doc is not None:
+        requests = []
+        for request in run_doc.jobs:
+            expanded = _doors(request.workflow, f"job {request.id!r}")
+            if expanded is None:
+                return EXIT_USAGE
+            requests.append(replace(request, workflow=expanded))
+        target = requests
+        workflow_doc: dict = {}
+    else:
+        expanded = _doors(args.workflow, "")
+        if expanded is None:
+            return EXIT_USAGE
+        workflow_doc = expanded
+        target = workflow_doc
 
     boundary = None
     if args.boundary:
@@ -323,7 +397,7 @@ def main(argv: Sequence[str] | None = None) -> int:
         # declare `_id`, mint the boundary's Object ids, share one IdGenerator with the
         # backend); it runs the rewritten document in memory (no temp file).
         result = run_labcode(
-            workflow_doc,
+            target,
             # The environment document read above, not its path: the dialect front door
             # already parsed it, and the runner takes a document (ofplang-run >= 0.1.13),
             # so the file is read once. The plan's `meta.environment` reads `<in-memory>`
@@ -357,6 +431,7 @@ def main(argv: Sequence[str] | None = None) -> int:
                 else FROM_ENVIRONMENT if args.op_timeout is None
                 else args.op_timeout
             ),
+            on_job_failure=args.on_job_failure,
             trace=args.trace,
             mission_id=args.mission_id,
             on_trace_id=report_trace_id,
@@ -389,7 +464,19 @@ def main(argv: Sequence[str] | None = None) -> int:
     write_err = _emit(result.status, args.output) or write_err
     if result.failed:
         failure = result.failure
-        if failure is not None:
+        # A run of named jobs reports one line per job that stopped: they stopped for
+        # unrelated reasons and naming only the first would hide the rest. A failure
+        # belonging to no job -- an unplannable replan, a refill that failed -- leaves
+        # that list empty and falls through to the run-level line, which is also the only
+        # line a single workflow ever prints.
+        if result.job_failures:
+            for job_id, reason in result.job_failures:
+                print(
+                    f"lc run: job {job_id!r} failed: {reason.kind}: {reason.detail}"
+                    f"{probe_note()}{timeout_note(reason.kind)}",
+                    file=sys.stderr,
+                )
+        elif failure is not None:
             print(
                 f"lc run: execution failed: {failure.kind}: {failure.detail}"
                 f"{probe_note()}{timeout_note(failure.kind)}",

{labcode-0.5.0 → labcode-0.7.0}/labcode/runner.py

@@ -17,7 +17,8 @@ building block; using it on an Object workflow without this runner fails (no rew
 from __future__ import annotations
 
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
+from dataclasses import replace
 from typing import Literal
 
 from ofplang.run.app import RunResult
@@ -39,9 +40,17 @@ class LabcodeRunner(RollingRunner):
 
     `workflow` and `environment` are each a path or an already-loaded document (the
     `lc run` front door passes the environment it has already read for its dialect check,
-    so the file is not read twice). Object types are rewritten to declare ``_id``, the boundary's
-    Object inputs are minted, and the labcode backend is wired with a shared `IdGenerator`
-    (default: reproducible, seeded). `seconds_per_tick` / `speed` / `spawn` / `monotonic` /
+    so the file is not read twice). `workflow` may instead be a **list of `JobRequest`s**
+    -- a run of several jobs planned together (schedule SPEC §6.11), each with its own
+    workflow, boundary and release. Everything labcode does to a workflow is then done
+    per job, and the identities are minted **per job**: two jobs of one workflow bind the
+    same port names and render the same node paths, so a reproducible generator keyed on
+    those alone would give one job's plate the other's `_id`. `boundary` must be left
+    unset for a roster, each job carrying its own.
+
+    Object types are rewritten to declare ``_id``, the boundary's Object inputs are
+    minted, and the labcode backend is wired with a shared `IdGenerator` (default:
+    reproducible, seeded). `seconds_per_tick` / `speed` / `spawn` / `monotonic` /
     `sleep` configure the wall-clock backend, `probe` / `prober` /
     `on_availability_change` its availability probing (`labcode.probe`), and `op_timeout`
     how long one operation may run before it is stopped and failed (default: whatever the
@@ -94,14 +103,13 @@ class LabcodeRunner(RollingRunner):
         recorder: Recorder | None = None,
         **rolling_kwargs,
     ) -> None:
-        doc = workflow if isinstance(workflow, dict) else load_document(workflow)
-        if not isinstance(doc, dict):
-            raise RunnerError("workflow must be a mapping")
-        clashes = reserved_collisions(doc)
-        if clashes:
+        roster = workflow if isinstance(workflow, Sequence) and not isinstance(
+            workflow, (str, bytes)
+        ) else None
+        if roster is not None and boundary is not None:
             raise RunnerError(
-                f"type(s) {clashes} declare the reserved view field '_id'; labcode owns it "
-                f"as an implicit Object identity and it must not be declared"
+                "a run of named jobs carries a boundary per job; pass each job's "
+                "boundary on its JobRequest rather than one for the run"
             )
         # A recorded run mints **real** ids by default: a reproducible generator gives the same
         # `_id` to the same port on every run, which is what makes the checked-in example
@@ -120,8 +128,27 @@ class LabcodeRunner(RollingRunner):
         self._on_trace_id = on_trace_id
         #: The id an operator can find this run's record by, once `run` has started it.
         self.trace_id: str | None = None
-        rewritten = inject_id_field(doc)
-        boundary = inject_boundary_ids(boundary, rewritten, self.id_generator)
+        # The same three steps per job, or once for a lone workflow: refuse a type that
+        # declares the reserved field, rewrite the Object types to carry `_id`, and mint
+        # the boundary's ids -- keyed by the job where the run names one.
+        if roster is None:
+            rewritten = self._prepare(workflow)
+            boundary = inject_boundary_ids(boundary, rewritten, self.id_generator)
+            target: object = rewritten
+        else:
+            prepared = []
+            for request in roster:
+                job_doc = self._prepare(request.workflow)
+                prepared.append(
+                    replace(
+                        request,
+                        workflow=job_doc,
+                        boundary=inject_boundary_ids(
+                            request.boundary, job_doc, self.id_generator, job=request.id
+                        ),
+                    )
+                )
+            target = prepared
         factory = labcode_backend_factory(
             seconds_per_tick=seconds_per_tick,
             speed=speed,
@@ -143,7 +170,7 @@ class LabcodeRunner(RollingRunner):
         if running_task_margin is None:
             running_task_margin = poll_interval if poll_interval is not None else 1
         super().__init__(
-            rewritten,
+            target,
             environment,
             boundary,
             backend_factory=factory,
@@ -152,6 +179,24 @@ class LabcodeRunner(RollingRunner):
             **rolling_kwargs,
         )
 
+    def _prepare(self, workflow) -> dict:
+        """One workflow, loaded and made a labcode workflow: the reserved-field check
+        and the ``_id`` type rewrite.
+
+        Per job rather than per run, because a roster's jobs need not run the same
+        workflow -- and because a job that declares the reserved field should be named
+        by the error rather than leaving the reader to find which of several it was."""
+        doc = workflow if isinstance(workflow, dict) else load_document(workflow)
+        if not isinstance(doc, dict):
+            raise RunnerError("workflow must be a mapping")
+        clashes = reserved_collisions(doc)
+        if clashes:
+            raise RunnerError(
+                f"type(s) {clashes} declare the reserved view field '_id'; labcode owns it "
+                f"as an implicit Object identity and it must not be declared"
+            )
+        return inject_id_field(doc)
+
     def run(self) -> dict:
         """Drive the workflow to completion, recording the run around it.
 
@@ -166,10 +211,38 @@ class LabcodeRunner(RollingRunner):
         except BaseException as exc:
             self._finish_record(type(exc).__name__, str(exc))
             raise
-        failure = self.failure
-        self._finish_record(*((failure.kind, failure.detail) if failure else (None, None)))
+        self._finish_record(*self._record_reason())
         return status
 
+    def _record_reason(self) -> tuple[str | None, str | None]:
+        """Why the run ended, for the record: one reason, however many jobs had one.
+
+        A run of a *laboratory* can stop several jobs for unrelated reasons (SPEC §6.11),
+        and `--on-job-failure continue` is what makes that the ordinary case rather than
+        a curiosity. The record keeps one run rather than one per job, so the reasons are
+        gathered into its message -- naming only the first would hide the rest, which is
+        the same conclusion the CLI reached about what it prints.
+
+        The `error_type` stays the run's own, because that is the code a reader filters
+        on, and a run of a single workflow is reported exactly as it always was: one job,
+        unnamed, one reason.
+        """
+        failure = self.failure
+        jobs = self.jobs
+        if len(jobs) == 1 and not jobs[0].id:  # a single workflow is a single job
+            return (failure.kind, failure.detail) if failure else (None, None)
+        per_job = [(job.id, job.failure) for job in jobs if job.failure is not None]
+        if not per_job:
+            # A failure belonging to no job: a refill that failed, or a replan nothing
+            # could be planned from. Neither can be attributed, and both stop everything.
+            return (failure.kind, failure.detail) if failure else (None, None)
+        return (
+            failure.kind if failure is not None else per_job[0][1].kind,
+            "; ".join(
+                f"{job_id}: {reason.kind}: {reason.detail}" for job_id, reason in per_job
+            ),
+        )
+
     def _finish_record(self, error_type: str | None, message: str | None) -> None:
         self.recorder.run_finished(error_type=error_type, message=message)
         self.recorder.shutdown()
@@ -192,6 +265,11 @@ def run_labcode(
     """Drive `workflow` on the labcode backend (with Object ``_id`` injected/minted) to
     completion and return a `RunResult` -- the labcode analogue of `ofplang.run.run_workflow`.
 
+    `workflow` may be a list of `JobRequest`s instead, a run of several jobs planned
+    together (schedule SPEC §6.11) -- `lc run --jobs`. `boundary` is then left unset,
+    each job carrying its own, and `on_job_failure` says what one job's failure does to
+    the rest.
+
     The caller is expected to have validated the workflow (the `lc run` front doors); this
     runs trusting. The labcode backend holds child processes, so its `close` is called in a
     `finally` whether the run finished or raised.