labnotes 0.2.7__tar.gz → 0.2.8__tar.gz

{labnotes-0.2.7 → labnotes-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.2.7
+Version: 0.2.8
 Summary: Browse experiment designs, notes, and run data from a folder.
 Project-URL: Repository, https://github.com/thekevinscott/labnotes
 Author-email: Kevin Scott <me@thekevinscott.com>
@@ -79,7 +79,8 @@ labnotes experiments foo runs   # foo's runs, oldest first
 Each takes `--format table` or `--format json`, which print rows and exit.
 Without `--format`, they open a browser in a terminal: the experiment list,
 Enter to open one, Escape to go back. `foo` and `foo runs` open straight on
-`foo`, which shows its runs grouped by invocation; Enter expands or collapses
+`foo`, which shows its runs, with runs that older versions nested in one invocation
+folder grouped under it; Enter expands or collapses
 one. Piped, they print a table.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
@@ -96,6 +97,7 @@ experiments folder:
 name = "Model and effort"
 command = "uv run scripts/study.py --output {run_dir}"
 repeats = 5
+continues = false
 
 [params]
 model = ["opus", "sonnet"]
@@ -107,6 +109,8 @@ and as `display_name` in `experiments`. The folder name stays the key, so
 renaming the experiment means editing `name`.
 Each combination of `[params]` runs `repeats` times, round-robin. Only runs
 that exit 0 count, so running again fills in what failed or never ran.
+`continues` is required: `true` invokes a failed run again in its own folder,
+`false` gives its combination a new one.
 Each run gets a new run folder. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
 script so it writes its outputs there.

{labnotes-0.2.7 → labnotes-0.2.8}/README.md

@@ -53,7 +53,8 @@ labnotes experiments foo runs   # foo's runs, oldest first
 Each takes `--format table` or `--format json`, which print rows and exit.
 Without `--format`, they open a browser in a terminal: the experiment list,
 Enter to open one, Escape to go back. `foo` and `foo runs` open straight on
-`foo`, which shows its runs grouped by invocation; Enter expands or collapses
+`foo`, which shows its runs, with runs that older versions nested in one invocation
+folder grouped under it; Enter expands or collapses
 one. Piped, they print a table.
 
 `labnotes experiments new [NAME]` creates an experiment folder with a starter
@@ -70,6 +71,7 @@ experiments folder:
 name = "Model and effort"
 command = "uv run scripts/study.py --output {run_dir}"
 repeats = 5
+continues = false
 
 [params]
 model = ["opus", "sonnet"]
@@ -81,6 +83,8 @@ and as `display_name` in `experiments`. The folder name stays the key, so
 renaming the experiment means editing `name`.
 Each combination of `[params]` runs `repeats` times, round-robin. Only runs
 that exit 0 count, so running again fills in what failed or never ran.
+`continues` is required: `true` invokes a failed run again in its own folder,
+`false` gives its combination a new one.
 Each run gets a new run folder. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
 script so it writes its outputs there.

labnotes-0.2.8/src/labnotes/config_migration.py

@@ -0,0 +1,12 @@
+MIGRATION = (
+    "https://github.com/thekevinscott/labnotes/blob/main/"
+    "docs/migrations.d/2026-11-02-python-remove-modes.md"
+)
+REMOVED_MODE = (
+    "mode was removed: every experiment plans what it is missing. "
+    f"Delete mode. See {MIGRATION}"
+)
+MISSING_CONTINUES = (
+    "continues is required: set continues = true or continues = false. "
+    f"See {MIGRATION}"
+)

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/context.md

@@ -55,6 +55,7 @@ experiments folder:
 name = "Model and effort"
 command = "uv run scripts/study.py --output {run_dir}"
 repeats = 5
+continues = false
 
 [params]
 model = ["opus", "sonnet"]
@@ -64,22 +65,26 @@ effort = ["low", "high"]
 `name` is optional: a display name for the experiment, shown in the live view
 and as `display_name` in `experiments`. The folder name stays the key, so
 renaming the experiment means editing `name`.
-Each combination of `[params]` runs `repeats` times (1 if omitted), round-robin, on every
-`run`, whatever is already on disk. That is `mode = "adhoc"`, the default.
-`mode = "matrix"` counts what is there: only runs that count fill a combination,
-so running again fills in what failed or never ran. `mode` under
-`[experiments]` in `.labnotes.toml` sets it for every experiment that doesn't
-set its own.
-Each run gets a new run folder. In `matrix` mode it is named for the UTC time it was planned
-(`runs/20261020-000429-brave-fox`). In `adhoc` mode a `run` command that plans one run names
-its folder the same way. One that plans more gets one folder named that way, and its runs nest
-inside it (`runs/20261020-000429-brave-fox/quiet-river`); the run id is that path under `runs/`. Either way, folder listings sort by start. `command` runs in a shell from the root, with
+Each combination of `[params]` needs `repeats` runs that count (1 if omitted).
+`run` plans only the combinations short of that, round-robin, so running again
+fills in what failed or never ran, and a finished experiment plans nothing
+(`Nothing to run: every combination has its repeats.`). To start over, copy it
+with `experiments new NAME --from OLD`, which drops `mode` and fills in
+`continues`. `mode` is gone; setting it is a config error.
+`continues` is required, in `experiment.toml` or `[experiment]` in
+`.labnotes.toml`. `continues = true` invokes a failed, stopped or lost run again
+in its own folder, with the same params and `{run_dir}`; `run.json` then lists
+each attempt under `"invocations"`. `continues = false` gives the combination a
+new folder. Never delete `run.json`, `stdout-*`, `stderr-*` or `run.lock` from a
+run folder.
+Each new run gets a run folder named for the UTC time it was planned
+(`runs/20261020-000429-brave-fox`), so folder listings sort by start. Older
+versions nested several runs in one invocation folder
+(`runs/20261020-000429-brave-fox/quiet-river`, run id is that path); those still
+list and count. Only one `run` of an experiment goes at a time; a second refuses. `command` runs in a shell from the root, with
 `{run_dir}` replaced by the run folder's absolute path. Pass it to the
-script so it writes its outputs there. `{invocation_dir}` is the shared adhoc
-group folder's absolute path when several runs are planned. With one planned
-run it stays at the first attempt's folder across retries, while `{run_dir}`
-changes per attempt. With several matrix runs, it equals each run's `{run_dir}`.
-Both placeholders are shell-quoted.
+script so it writes its outputs there. `{invocation_dir}` is the same
+folder as `{run_dir}`. Both placeholders are shell-quoted.
 Each param is appended as `--name value`, with the name as written (use
 `source-language` for a `--source-language` flag), booleans as 0 or 1, and lists
 and tables as JSON. labnotes writes `run.json` (params, `command`, created,
@@ -114,9 +119,7 @@ existing value without dropping other keys. Values must be JSON serializable;
 reading before any write returns `{}`. Runs can only read: `set_state` raises
 `RuntimeError` there. Both functions raise outside an invocation and in `meta`.
 Labnotes gives setup/teardown `LABNOTES_STATE` and runs `LABNOTES_RUN_STATE`,
-pointing to `state.json` in the multi-run adhoc group folder or the lone run's
-folder, or, without a shared folder, a temp
-file kept through all runs and teardown and then removed. Queued runs and retries
+pointing to a temp file kept through all runs and teardown and then removed. Queued runs and retries
 read the same file after setup finishes. `meta` receives neither state variable;
 state is never copied into `run.json`.
 Nested labnotes invocations clear inherited `LABNOTES_*` context for their
@@ -182,7 +185,7 @@ Escape clears it. `x` stops the
 running run under the cursor; `x` again kills it. `+` and
 `-` change how many run at once; lowering it lets running runs
 finish. Enter on a run follows its `stdout.log` and `stderr.log` together, as
-they're written, and Escape returns to the table. An `adhoc` experiment that
+they're written, and Escape returns to the table. A `run` that
 plans a single run opens straight on its output. `q` quits and leaves the runs
 going. Elsewhere, it prints a line per event instead.
 
@@ -218,4 +221,4 @@ going. Elsewhere, it prints a line per event instead.
   was retried counts as retried, not failed. If it can't
   start a run, it prints the cause on one line and exits 1.
 
-`uvx labnotes server` serves the experiments, their markdown files and their runs as a local site, read from the same `.labnotes.toml`. An experiment's page shows its `experiment.toml` on one line, then a Runs tab with a table of its runs and a Notebooks tab with one tab per markdown file. For a matrix experiment, the Runs tab also has a grid (`?view=grid`): one cell per combination of the params that vary, with how many runs count toward `repeats`. Clicking a run opens its `stdout.log` and `stderr.log` together, followed as they're written until the run ends.
+`uvx labnotes server` serves the experiments, their markdown files and their runs as a local site, read from the same `.labnotes.toml`. An experiment's page shows its `experiment.toml` on one line, then a Runs tab with a table of its runs and a Notebooks tab with one tab per markdown file. The Runs tab also has a grid (`?view=grid`): one cell per combination of the params that vary, with how many runs count toward `repeats`. Clicking a run opens its `stdout.log` and `stderr.log` together, followed as they're written until the run ends.

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/create_app.py

@@ -63,7 +63,7 @@ def create_app(config: LabnotesConfig) -> Starlette:
             await kernel.stop()
 
     async def index(request: Request) -> Response:
-        experiments = await list_experiments(request.app.state.tables, config.mode)
+        experiments = await list_experiments(request.app.state.tables)
         return templates.TemplateResponse(
             request,
             "index.html",
@@ -75,7 +75,6 @@ def create_app(config: LabnotesConfig) -> Starlette:
         loaded = await load_experiment(
             request.app.state.tables,
             config.root,
-            config.mode,
             name,
             request.query_params,
             lambda note, content: saved_outputs(kernels.get((name, note)), content),

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/create_experiment.py

@@ -10,6 +10,8 @@ STARTER = """\
 # Runs from the project root. {run_dir} becomes the run's folder.
 command = "uv run script.py --output {run_dir}"
 repeats = 1
+# true: a failed run starts again in its own folder instead of a new one.
+continues = false
 
 # Each combination runs `repeats` times, passed as --name value.
 [params]
@@ -41,7 +43,8 @@ def create_experiment(
     path = folder(name)
     if path.exists():
         raise ValueError(f"{name} already exists at {path}.")
-    text = STARTER
+    inherited = config.defaults.get("continues") is True
+    text = STARTER.replace("continues = false", f"continues = {str(inherited).lower()}")
     if source is not None:
         origin = folder(source) / "experiment.toml"
         if not origin.is_file():
@@ -53,7 +56,7 @@ def create_experiment(
     else:
         path.mkdir(parents=True)
     (path / "experiment.toml").write_text(
-        experiment_definition(text, source, command, repeats, params or {}),
+        experiment_definition(text, source, command, repeats, params or {}, inherited),
         encoding="utf-8",
     )
     return path

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/experiment_definition.py

@@ -7,13 +7,17 @@ def experiment_definition(
     command: str | None,
     repeats: int | None,
     params: dict[str, list[object]],
+    continues: bool = False,
 ) -> str:
     document = tomlkit.parse(text)
     document.pop("from", None)
+    document.pop("mode", None)
     if command is not None:
         document["command"] = command
     if repeats is not None:
         document["repeats"] = repeats
+    if "continues" not in document:
+        document["continues"] = continues
     if params:
         table = document.setdefault("params", tomlkit.table())
         for name, values in params.items():

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/list_experiments.py

@@ -9,7 +9,7 @@ from labnotes.experiment_runs import experiment_runs
 from labnotes.summarize_config import summarize_config
 
 
-async def list_experiments(tables: DirSQL, mode: str) -> list[dict[str, object]]:
+async def list_experiments(tables: DirSQL) -> list[dict[str, object]]:
     rows = await tables.query(
         "SELECT name, display_name, config FROM experiments ORDER BY name"
     )
@@ -17,7 +17,7 @@ async def list_experiments(tables: DirSQL, mode: str) -> list[dict[str, object]]
     for row in rows:
         name = str(row["name"])
         config = None if row["config"] is None else json.loads(str(row["config"]))
-        summary = summarize_config(config, mode)
+        summary = summarize_config(config)
         varies = cast(dict[str, list[object]], summary["varies"])
         source = experiment_runs(name, list(varies))
         summary = await check_counts(tables, source, summary)

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/load_experiment.py

@@ -33,7 +33,6 @@ def _no_outputs(note: str, content: str) -> Sequence[str]:
 async def load_experiment(
     tables: DirSQL,
     root: Path,
-    mode: str,
     name: str,
     params: QueryParams,
     outputs_for: Callable[[str, str], Sequence[str]] = _no_outputs,
@@ -46,7 +45,7 @@ async def load_experiment(
         return None
     [row] = found
     config = None if row["config"] is None else json.loads(str(row["config"]))
-    summary = summarize_config(config, mode)
+    summary = summarize_config(config)
     varies = cast(dict[str, list[object]], summary["varies"])
     source = experiment_runs(name, list(varies))
     summary = await check_counts(tables, source, summary)
@@ -72,14 +71,13 @@ async def load_experiment(
         )
 
     runs_live = any(is_running(run) for run in runs)
-    nested = summary["mode"] == "adhoc" and await nests_runs(tables, source)
+    nested = await nests_runs(tables, source)
     groups = (
         group_runs(runs, list(choices), await count_groups(tables, source))
         if nested
         else None
     )
-    matrix = summary["mode"] == "matrix"
-    gridded = matrix and params.getlist("view")[-1:] == ["grid"]
+    gridded = params.getlist("view")[-1:] == ["grid"]
     axes = {key: varies[key] for key in choices if len(varies[key]) > 1}
     grid = (
         pivot_runs(

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/models.py

@@ -5,7 +5,6 @@ from typing import Any, Protocol
 
 from labnotes.default_counts import DEFAULT_COUNTS
 from labnotes.memory_interval import DEFAULT_MEMORY_INTERVAL
-from labnotes.modes import DEFAULT_MODE
 from labnotes.retries import DEFAULT_RETRIES
 
 Report = Callable[[dict[str, object]], None]
@@ -43,7 +42,6 @@ class LabnotesConfig:
     experiments: str
     files: str
     runs: str
-    mode: str = DEFAULT_MODE
     concurrency: int = 1
     retries: int = DEFAULT_RETRIES
     # Set when the config's folder is itself the one experiment.
@@ -59,7 +57,6 @@ class ExperimentConfig:
     params: dict[str, list[object]]
     name: str | None = None
     counts: str = DEFAULT_COUNTS
-    mode: str = DEFAULT_MODE
     concurrency: int = 1
     retries: int = DEFAULT_RETRIES
     meta: str | None = None

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/read_config.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from labnotes.models import LabnotesConfig
 from labnotes.is_non_negative_int import is_non_negative_int
 from labnotes.is_positive_int import is_positive_int
-from labnotes.modes import DEFAULT_MODE, MODES
+from labnotes.config_migration import REMOVED_MODE
 from labnotes.runner.read_experiment_config import SETTINGS
 from labnotes.read_path import DEFAULT_PATHS, read_path
 from labnotes.retries import DEFAULT_RETRIES
@@ -25,6 +25,8 @@ def read_config(path: Path) -> LabnotesConfig:
     defaults = values.get("experiment", {})
     if not isinstance(defaults, dict):
         raise ValueError(f"{path}: experiment must be a table, like [experiment]")
+    if "mode" in defaults:
+        raise ValueError(f"{path}: [experiment] {REMOVED_MODE}")
     unknown = sorted(defaults.keys() - SETTINGS)
     if unknown:
         raise ValueError(f"{path}: unknown keys in [experiment]: {', '.join(unknown)}")
@@ -39,9 +41,8 @@ def read_config(path: Path) -> LabnotesConfig:
         table: read_path(path, table, values.get(table, {}), single=single)
         for table in DEFAULT_PATHS
     }
-    mode = experiments.get("mode", DEFAULT_MODE)
-    if mode not in MODES:
-        raise ValueError(f"{path}: [experiments] mode must be matrix or adhoc")
+    if "mode" in experiments:
+        raise ValueError(f"{path}: [experiments] {REMOVED_MODE}")
     concurrency = experiments.get("concurrency", 1)
     if not is_positive_int(concurrency):
         raise ValueError(
@@ -54,7 +55,6 @@ def read_config(path: Path) -> LabnotesConfig:
         path.resolve(),
         root,
         **paths,
-        mode=mode,
         concurrency=concurrency,
         retries=retries,
         experiment=root.name if single else None,

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/runner/describe_event.py

@@ -7,6 +7,8 @@ def describe_event(event: dict[str, object]) -> str:
     match event["event"]:
         case "planned":
             runs = len(event["runs"])  # type: ignore[arg-type]
+            if not runs:
+                return "Nothing to run: every combination has its repeats."
             return f"{runs} runs to go, {event['concurrency']} at a time."
         case "started":
             args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]

labnotes-0.2.8/src/labnotes/runner/hold_experiment.py

@@ -0,0 +1,29 @@
+import fcntl
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager, suppress
+
+from labnotes.models import LabnotesConfig
+from labnotes.runner.runs_parent import runs_parent
+
+
+@contextmanager
+def hold_experiment(config: LabnotesConfig, name: str) -> Iterator[None]:
+    folder = runs_parent(config.root, config.runs, name)
+    made = not folder.exists()
+    folder.mkdir(parents=True, exist_ok=True)
+    descriptor = os.open(folder, os.O_RDONLY)
+    try:
+        try:
+            fcntl.flock(descriptor, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            raise ValueError(
+                f"{name} is already running in another labnotes run."
+                " Wait for it to finish, or stop it, then run again."
+            ) from None
+        yield
+    finally:
+        if made:
+            with suppress(OSError):
+                folder.rmdir()
+        os.close(descriptor)

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/runner/prepare_experiment.py

@@ -31,7 +31,6 @@ async def prepare_experiment(
     experiment = read_experiment_config(
         config.path if source is None else experiment_config,
         source or "",
-        config.mode,
         config.concurrency,
         config.retries,
         config.defaults,

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/runner/read_experiment_config.py

@@ -10,7 +10,7 @@ from labnotes.is_non_negative_int import is_non_negative_int
 from labnotes.is_non_negative_number import is_non_negative_number
 from labnotes.memory_interval import DEFAULT_MEMORY_INTERVAL
 from labnotes.is_positive_int import is_positive_int
-from labnotes.modes import MODES
+from labnotes.config_migration import MISSING_CONTINUES, REMOVED_MODE
 
 SETTINGS = {
     "name",
@@ -18,7 +18,6 @@ SETTINGS = {
     "repeats",
     "params",
     "counts",
-    "mode",
     "concurrency",
     "retries",
     "meta",
@@ -37,7 +36,6 @@ VIEWS = {"runs"}
 def read_experiment_config(
     path: Path,
     source: str,
-    mode: str,
     concurrency: int,
     retries: int,
     defaults: dict[str, object] | None = None,
@@ -47,6 +45,8 @@ def read_experiment_config(
     except tomllib.TOMLDecodeError as error:
         raise ValueError(f"{path}: {error}") from error
     values: dict[str, Any] = compose_experiment(defaults or {}, layer)
+    if "mode" in values:
+        raise ValueError(f"{path}: {REMOVED_MODE}")
     unknown = sorted(values.keys() - SETTINGS)
     if unknown:
         raise ValueError(f"{path}: unknown keys {', '.join(unknown)}")
@@ -72,9 +72,6 @@ def read_experiment_config(
     counts = values.get("counts", DEFAULT_COUNTS)
     if not isinstance(counts, str) or not counts.strip():
         raise ValueError(f"{path}: counts must be a SQL condition")
-    mode = values.get("mode", mode)
-    if mode not in MODES:
-        raise ValueError(f"{path}: mode must be matrix or adhoc")
     concurrency = values.get("concurrency", concurrency)
     if not is_positive_int(concurrency):
         raise ValueError(f"{path}: concurrency must be a positive integer")
@@ -102,11 +99,11 @@ def read_experiment_config(
             raise ValueError(f"{path}: env.{key} is reserved for labnotes")
         if not isinstance(value, str):
             raise ValueError(f"{path}: env.{key} must be a string")
-    continues = values.get("continues", False)
+    if "continues" not in values:
+        raise ValueError(f"{path}: {MISSING_CONTINUES}")
+    continues = values["continues"]
     if not isinstance(continues, bool):
         raise ValueError(f"{path}: continues must be true or false")
-    if continues and mode != "matrix":
-        raise ValueError(f'{path}: continues needs mode = "matrix"')
     views = values.get("views", {})
     if not isinstance(views, dict):
         raise ValueError(f"{path}: views must be a table, like [views]")
@@ -122,7 +119,6 @@ def read_experiment_config(
         params,
         name,
         counts,
-        mode,
         concurrency,
         retries,
         meta,

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/runner/run_experiment.py

@@ -2,7 +2,6 @@ import asyncio
 import json
 import os
 import signal
-from contextlib import nullcontext
 from pathlib import Path
 from tempfile import TemporaryDirectory
 
@@ -24,9 +23,9 @@ from labnotes.runner.fill_dirs import fill_dirs
 from labnotes.runner.in_subset import in_subset
 from labnotes.runner.invocation_hook import invocation_hook
 from labnotes.runner.invocation_meta import invocation_meta
-from labnotes.runner.new_param_run_id import new_param_run_id
 from labnotes.runner.new_stamped_run_id import new_stamped_run_id
 from labnotes.runner.param_grid import param_grid
+from labnotes.runner.placeholders import PLACEHOLDERS
 from labnotes.runner.plan_runs import plan_runs
 from labnotes.runner.project_snapshot import ProjectSnapshot
 from labnotes.runner.run_folder import run_folder
@@ -59,11 +58,8 @@ async def run_experiment(
     inherited = dict(os.environ) if environment is None else environment
     tables = open_tables(config)
     existing = await experiment_run_ids(tables, name)
-    finished: list[dict[str, object]] = []
-    match experiment.mode:
-        case "matrix":
-            counted = await list_experiment_runs(tables, name, experiment.counts)
-            finished = [json.loads(str(r["params"])) for r in counted if r["counted"]]
+    counted = await list_experiment_runs(tables, name, experiment.counts)
+    finished = [json.loads(str(r["params"])) for r in counted if r["counted"]]
     planned: set[str] = set()
 
     def taken(run: str) -> bool:
@@ -73,17 +69,6 @@ async def run_experiment(
         cell for cell in param_grid(experiment.params) if in_subset(cell, only or {})
     ]
     cells = plan_runs(grid, experiment.repeats, finished)
-    group = None
-    match experiment.mode:
-        case "adhoc" if len(cells) > 1:
-            group = new_stamped_run_id(taken)
-
-    def new_id(params: dict[str, object]) -> str:
-        if group is None:
-            return new_stamped_run_id(taken)
-        return f"{group}/" + new_param_run_id(
-            params, experiment.params, lambda run: taken(f"{group}/{run}")
-        )
 
     locks: dict[str, int] = {}
 
@@ -115,18 +100,9 @@ async def run_experiment(
             ),
             None,
         )
-        run = new_id(params) if resumed is None else resumed[0]
+        run = new_stamped_run_id(taken) if resumed is None else resumed[0]
         planned.add(run)
         plan.append((run, params))
-    run_dirs = [
-        str(run_folder(config.root, config.runs, name, run).resolve())
-        for run, _ in plan
-    ]
-    group_dir = (
-        str(run_folder(config.root, config.runs, name, group).resolve())
-        if group is not None
-        else None
-    )
     hooks = {
         "setup": experiment.setup,
         "teardown": experiment.teardown,
@@ -141,12 +117,6 @@ async def run_experiment(
     meta = None
     if experiment.meta is not None:
         meta = await invocation_meta(command_root, experiment.meta, hook_env["meta"])
-    invocation_dir = group_dir
-    match run_dirs:
-        case [run_dir]:
-            invocation_dir = run_dir
-    if invocation_dir is not None:
-        Path(invocation_dir).mkdir(parents=True, exist_ok=True)
     runs = [{"run": run, "params": params} for run, params in plan]
     report(
         {
@@ -154,7 +124,6 @@ async def run_experiment(
             "title": experiment.name or name,
             "runs": runs,
             "concurrency": concurrency,
-            "mode": experiment.mode,
         }
     )
     running: dict[str, set[asyncio.subprocess.Process]] = {}
@@ -208,7 +177,7 @@ async def run_experiment(
     def requeue(run: str, attempt: int) -> None:
         again = run
         if not experiment.continues:
-            again = new_id(ended[run])
+            again = new_stamped_run_id(taken)
             planned.add(again)
             parents[again] = run
         attempts[again] = attempt
@@ -284,8 +253,9 @@ async def run_experiment(
         if snapshot is not None and snapshot.sha is not None:
             (folder / "git-sha.txt").write_text(snapshot.sha + "\n")
             (folder / "git-diff.patch").write_bytes(snapshot.diff or b"")
-        run_invocation_dir = invocation_dir or str(folder.resolve())
         report({"event": "started", "run": run, "params": params, "folder": folder})
+        # {invocation_dir} stays for configs written before runs were flat.
+        dirs = dict.fromkeys(PLACEHOLDERS, str(folder.resolve()))
         running[run] = set()
         trees[run] = set()
         result = await execute_run(
@@ -293,10 +263,7 @@ async def run_experiment(
             folder,
             fill_dirs(
                 experiment.command,
-                {
-                    "run_dir": str(folder.resolve()),
-                    "invocation_dir": run_invocation_dir,
-                },
+                dirs,
             ),
             params,
             running[run],
@@ -313,10 +280,7 @@ async def run_experiment(
             environment=fill_experiment_env(
                 experiment.env,
                 inherited,
-                {
-                    "run_dir": str(folder.resolve()),
-                    "invocation_dir": run_invocation_dir,
-                },
+                dirs,
             ),
             git_info=(
                 {"commit": snapshot.sha, "dirty": bool(snapshot.diff)}
@@ -348,11 +312,7 @@ async def run_experiment(
             )
 
     listen(Controls(interrupt, set_concurrency, kill, finish))
-    with (
-        nullcontext(invocation_dir)
-        if invocation_dir is not None
-        else TemporaryDirectory(prefix="labnotes-state-")
-    ) as state_dir:
+    with TemporaryDirectory(prefix="labnotes-state-") as state_dir:
         state_file = Path(state_dir) / "state.json"
         for hook in ("setup", "teardown"):
             if hook in hook_env:

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/runner/start_experiment.py

@@ -2,6 +2,7 @@ from pathlib import Path
 
 from labnotes.models import LabnotesConfig, Listen, Report, Start
 from labnotes.runner.finalize_lost_runs import finalize_lost_runs
+from labnotes.runner.hold_experiment import hold_experiment
 from labnotes.runner.prepare_experiment import prepare_experiment
 from labnotes.runner.project_snapshot import project_snapshot
 from labnotes.runner.run_experiment import run_experiment
@@ -24,7 +25,7 @@ def start_experiment(
             config, name, experiment_config, concurrency, only, args, setup, teardown
         )
         await finalize_lost_runs(config)
-        with project_snapshot(config.root) as snapshot:
+        with project_snapshot(config.root) as snapshot, hold_experiment(config, name):
             return await run_experiment(
                 config,
                 name,

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/summarize_config.py

@@ -3,7 +3,7 @@ from math import prod
 from labnotes.default_counts import DEFAULT_COUNTS
 
 
-def summarize_config(config: dict[str, object] | None, mode: str) -> dict[str, object]:
+def summarize_config(config: dict[str, object] | None) -> dict[str, object]:
     config = config or {}
     params = config.get("params")
     varies = {
@@ -15,13 +15,11 @@ def summarize_config(config: dict[str, object] | None, mode: str) -> dict[str, o
     cells = prod(len(values) for values in varies.values())
     command = config.get("command")
     counts = config.get("counts")
-    matrix = config.get("mode", mode) == "matrix"
     return {
         "fixed": {},
         "varies": varies,
         "cell_count": cells,
         "runs_per_cell": repeats,
         "completed_run": counts if isinstance(counts, str) else DEFAULT_COUNTS,
-        "mode": "matrix" if matrix else "adhoc",
         "other": {} if command is None else {"command": command},
     }

{labnotes-0.2.7 → labnotes-0.2.8}/src/labnotes/tables/experiment_rows.py

@@ -19,9 +19,7 @@ async def experiment_rows(
         case str(), "runs":
             [row] = rows
             stored = row["config"]
-            summary = summarize_config(
-                json.loads(str(stored)) if stored else None, config.mode
-            )
+            summary = summarize_config(json.loads(str(stored)) if stored else None)
             runs = await list_experiment_runs(
                 tables, name, str(summary["completed_run"])
             )