labnotes 0.0.13__tar.gz → 0.0.15__tar.gz

{labnotes-0.0.13 → labnotes-0.0.15}/.gitignore

@@ -2,6 +2,7 @@ target/
 node_modules/
 dist/
 coverage/
+.coverage
 *.log
 .DS_Store
 

labnotes-0.0.15/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.5
+Name: labnotes
+Version: 0.0.15
+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>
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: click>=8.5.0
+Requires-Dist: dirsql>=0.4.110
+Requires-Dist: filelock>=4.2.0
+Requires-Dist: haikunator>=2.1.0
+Requires-Dist: ipykernel>=7.4.0
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: jupyter-client>=8.10.0
+Requires-Dist: markdown-it-py>=4.2.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14
+Requires-Dist: starlette>=1.8.0
+Requires-Dist: textual>=8.2.8
+Requires-Dist: uvicorn>=0.54.0
+Description-Content-Type: text/markdown
+
+# labnotes
+
+Browse experiment designs, notes, and run data from a folder.
+
+```sh
+uvx labnotes server
+```
+
+A project's root is the folder holding its `.labnotes.toml`. `labnotes init`
+writes one with the default layout:
+
+```toml
+[experiments]
+path = "{experiment}"
+
+[files]
+path = "{experiment}/files/"
+
+[runs]
+path = "{experiment}/runs/{run}"
+```
+
+Each path is relative to the root. `{experiment}` and `{run}` stand for folder
+names: the experiments path must use `{experiment}`, and the runs path both.
+labnotes reads the file from the working folder, or from the path given with
+`-c`.
+
+`labnotes experiments` reads three tables from those paths:
+
+- `experiments`: `name`, and `config`, the experiment's `experiment.toml` as
+  JSON. An experiment is a folder matching the experiments path that holds an
+  `experiment.toml`, files or runs.
+- `files`: `experiment`, `filename`, `path`, `ctime`, `mtime`.
+- `runs`: `experiment`, `id`, `folder`, `created`, `ended`, `exit_code`,
+  `error`, `stdout`, `stderr`, and `params` as JSON, read from each run
+  folder's `run.json`.
+
+Keys come from folder names, so renaming a folder renames its rows on the next
+read. Paths are relative to the root, and times are UTC ISO 8601.
+
+```sh
+labnotes experiments            # name, last_run, created, files, runs
+labnotes experiments foo        # the same, plus config
+labnotes experiments foo runs   # foo's runs, oldest first
+```
+
+Each takes `--format table` (the default) or `--format json`.
+
+`labnotes experiments foo run` runs `foo` from its `experiment.toml`, in the
+experiments folder:
+
+```toml
+command = "uv run scripts/study.py --output {run_dir}"
+repeats = 5
+
+[params]
+model = ["opus", "sonnet"]
+effort = ["low", "high"]
+```
+
+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.
+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.
+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, created, ended, exit
+code), `stdout.log` and `stderr.log` to the run folder.
+
+In a terminal, `run` shows a live table of runs (status and time) and stays
+open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+line per event instead.
+
+- `--concurrency N` runs N at a time (default 1).
+- `-e PATH` reads another file instead of `experiment.toml`.
+- Ctrl-C stops the running scripts and records their end. A second Ctrl-C
+  kills them.
+- A second `run` of the same experiment fails while the first holds the lock.
+- It exits 1 if any run failed.
+
+`labnotes server` doesn't read `.labnotes.toml` yet. Give it the two folders
+it uses with `--experiments-folder` and `--data-folder`:
+
+- `--experiments-folder` holds one subfolder per experiment, each with a
+  `design.yaml` (with a `study` key) and any number of markdown notes.
+- `--data-folder` holds the run data and a `.dirsql.toml` that declares a
+  `runs` table with a `study` column. An experiment's runs are the rows whose
+  `study` matches its design's.
+
+That serves a local site at http://127.0.0.1:8000: a table of experiments,
+and a page per experiment with its parameters, its notes, progress per cell of
+the design grid, and every run so far. Both folders are watched, so a reload
+shows new runs and edited notes.
+
+`design.yaml` keys the site reads: `study`, `fixed`, `varies` (each key a list
+of values), `runs_per_cell`, and `completed_run`, a SQL condition over the
+`runs` table that marks a run as complete. Anything else shows up as-is.
+
+`-h`/`--host` and `-p`/`--port` change where it listens; `-h 0.0.0.0` (or a
+Tailscale IP) serves beyond localhost. Every other uvicorn option passes
+through: `--reload`, `--workers`, `--proxy-headers`, `--root-path`, the
+`--ssl-*` set, and the rest. `labnotes server --help` lists them. `LABNOTES_EXPERIMENTS_FOLDER` and
+`LABNOTES_DATA_FOLDER` can stand in for the folder flags.
+
+## Agent skill
+
+```sh
+npx skills add thekevinscott/labnotes
+```
+
+The skill tells a coding agent to run `labnotes context`, which prints a usage
+guide for the installed version.

labnotes-0.0.15/README.md

@@ -0,0 +1,113 @@
+# labnotes
+
+Browse experiment designs, notes, and run data from a folder.
+
+```sh
+uvx labnotes server
+```
+
+A project's root is the folder holding its `.labnotes.toml`. `labnotes init`
+writes one with the default layout:
+
+```toml
+[experiments]
+path = "{experiment}"
+
+[files]
+path = "{experiment}/files/"
+
+[runs]
+path = "{experiment}/runs/{run}"
+```
+
+Each path is relative to the root. `{experiment}` and `{run}` stand for folder
+names: the experiments path must use `{experiment}`, and the runs path both.
+labnotes reads the file from the working folder, or from the path given with
+`-c`.
+
+`labnotes experiments` reads three tables from those paths:
+
+- `experiments`: `name`, and `config`, the experiment's `experiment.toml` as
+  JSON. An experiment is a folder matching the experiments path that holds an
+  `experiment.toml`, files or runs.
+- `files`: `experiment`, `filename`, `path`, `ctime`, `mtime`.
+- `runs`: `experiment`, `id`, `folder`, `created`, `ended`, `exit_code`,
+  `error`, `stdout`, `stderr`, and `params` as JSON, read from each run
+  folder's `run.json`.
+
+Keys come from folder names, so renaming a folder renames its rows on the next
+read. Paths are relative to the root, and times are UTC ISO 8601.
+
+```sh
+labnotes experiments            # name, last_run, created, files, runs
+labnotes experiments foo        # the same, plus config
+labnotes experiments foo runs   # foo's runs, oldest first
+```
+
+Each takes `--format table` (the default) or `--format json`.
+
+`labnotes experiments foo run` runs `foo` from its `experiment.toml`, in the
+experiments folder:
+
+```toml
+command = "uv run scripts/study.py --output {run_dir}"
+repeats = 5
+
+[params]
+model = ["opus", "sonnet"]
+effort = ["low", "high"]
+```
+
+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.
+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.
+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, created, ended, exit
+code), `stdout.log` and `stderr.log` to the run folder.
+
+In a terminal, `run` shows a live table of runs (status and time) and stays
+open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+line per event instead.
+
+- `--concurrency N` runs N at a time (default 1).
+- `-e PATH` reads another file instead of `experiment.toml`.
+- Ctrl-C stops the running scripts and records their end. A second Ctrl-C
+  kills them.
+- A second `run` of the same experiment fails while the first holds the lock.
+- It exits 1 if any run failed.
+
+`labnotes server` doesn't read `.labnotes.toml` yet. Give it the two folders
+it uses with `--experiments-folder` and `--data-folder`:
+
+- `--experiments-folder` holds one subfolder per experiment, each with a
+  `design.yaml` (with a `study` key) and any number of markdown notes.
+- `--data-folder` holds the run data and a `.dirsql.toml` that declares a
+  `runs` table with a `study` column. An experiment's runs are the rows whose
+  `study` matches its design's.
+
+That serves a local site at http://127.0.0.1:8000: a table of experiments,
+and a page per experiment with its parameters, its notes, progress per cell of
+the design grid, and every run so far. Both folders are watched, so a reload
+shows new runs and edited notes.
+
+`design.yaml` keys the site reads: `study`, `fixed`, `varies` (each key a list
+of values), `runs_per_cell`, and `completed_run`, a SQL condition over the
+`runs` table that marks a run as complete. Anything else shows up as-is.
+
+`-h`/`--host` and `-p`/`--port` change where it listens; `-h 0.0.0.0` (or a
+Tailscale IP) serves beyond localhost. Every other uvicorn option passes
+through: `--reload`, `--workers`, `--proxy-headers`, `--root-path`, the
+`--ssl-*` set, and the rest. `labnotes server --help` lists them. `LABNOTES_EXPERIMENTS_FOLDER` and
+`LABNOTES_DATA_FOLDER` can stand in for the folder flags.
+
+## Agent skill
+
+```sh
+npx skills add thekevinscott/labnotes
+```
+
+The skill tells a coding agent to run `labnotes context`, which prints a usage
+guide for the installed version.

{labnotes-0.0.13 → labnotes-0.0.15}/pyproject.toml

@@ -13,12 +13,16 @@ authors = [{ name = "Kevin Scott", email = "me@thekevinscott.com" }]
 dependencies = [
     "click>=8.5.0",
     "dirsql>=0.4.110",
+    "filelock>=4.2.0",
+    "haikunator>=2.1.0",
     "ipykernel>=7.4.0",
     "jinja2>=3.1.6",
     "jupyter-client>=8.10.0",
     "markdown-it-py>=4.2.0",
     "pyyaml>=6.0.3",
+    "rich>=14",
     "starlette>=1.8.0",
+    "textual>=8.2.8",
     "uvicorn>=0.54.0",
 ]
 
@@ -51,7 +55,7 @@ exclude = ["*_test.py"]
 packages = ["src/labnotes"]
 
 [tool.pytest.ini_options]
-testpaths = ["src/labnotes"]
+testpaths = ["src/labnotes", "tests"]
 python_files = "*_test.py"
 
 [tool.ruff.lint]
@@ -61,3 +65,8 @@ select = ["E4", "E7", "E9", "F", "TID252"]
 
 [tool.ruff.lint.flake8-tidy-imports]
 ban-relative-imports = "all"
+
+# haikunator ships no type hints.
+[[tool.mypy.overrides]]
+module = ["haikunator"]
+ignore_missing_imports = true

{labnotes-0.0.13 → labnotes-0.0.15}/src/labnotes/cli.py

@@ -3,6 +3,8 @@ from pathlib import Path
 import click
 
 from labnotes.context_guide import context_guide
+from labnotes.experiments import experiments
+from labnotes.init import init
 from labnotes.load_config import load_config
 from labnotes.read_config import CONFIG_FILE
 from labnotes.server import server
@@ -35,4 +37,6 @@ def context(ctx: click.Context) -> None:
     click.echo(context_guide(load_config(ctx), Path.cwd()), nl=False)
 
 
+main.add_command(experiments)
+main.add_command(init)
 main.add_command(server)

labnotes-0.0.15/src/labnotes/context.md

@@ -0,0 +1,80 @@
+## Usage
+
+A project that uses labnotes has a `.labnotes.toml` at its root; the folder holding it is the root. labnotes reads it from the working folder, so run labnotes from the project root, or pass `-c PATH`. The lines above this guide name the one found and its paths, or say there is none. `labnotes init` writes one with the default layout:
+
+```toml
+[experiments]
+path = "{experiment}"            # one folder per experiment
+
+[files]
+path = "{experiment}/files/"     # an experiment's notes and other files
+
+[runs]
+path = "{experiment}/runs/{run}" # one folder per run
+```
+
+Paths are relative to the root. `{experiment}` and `{run}` stand for folder names; the experiments and files paths use `{experiment}`, the runs path both. A project laid out differently keeps its folders and changes the paths: look at where its experiments, notes and runs live, then write the templates that match.
+
+`labnotes experiments` reads three tables from those paths:
+
+- `experiments`: `name`, and `config`, the experiment's `experiment.toml` as
+  JSON. An experiment is a folder matching the experiments path that holds an
+  `experiment.toml`, files or runs.
+- `files`: `experiment`, `filename`, `path`, `ctime`, `mtime`.
+- `runs`: `experiment`, `id`, `folder`, `created`, `ended`, `exit_code`,
+  `error`, `stdout`, `stderr`, and `params` as JSON, read from each run
+  folder's `run.json`.
+
+Keys come from folder names, so renaming a folder renames its rows on the next
+read. Paths are relative to the root, and times are UTC ISO 8601.
+
+```sh
+labnotes experiments            # name, last_run, created, files, runs
+labnotes experiments foo        # the same, plus config
+labnotes experiments foo runs   # foo's runs, oldest first
+```
+
+Each takes `--format table` (the default) or `--format json`; use `--format json` when you parse the output.
+
+`labnotes experiments foo run` runs `foo` from its `experiment.toml`, in the
+experiments folder:
+
+```toml
+command = "uv run scripts/study.py --output {run_dir}"
+repeats = 5
+
+[params]
+model = ["opus", "sonnet"]
+effort = ["low", "high"]
+```
+
+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.
+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.
+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, created, ended, exit
+code), `stdout.log` and `stderr.log` to the run folder.
+
+In a terminal, `run` shows a live table of runs (status and time) and stays
+open when they finish; `q` quits. Elsewhere, or with `--no-tui`, it prints a
+line per event instead.
+
+- `--concurrency N` runs N at a time (default 1).
+- `-e PATH` reads another file instead of `experiment.toml`.
+- Ctrl-C stops the running scripts and records their end. A second Ctrl-C
+  kills them.
+- A second `run` of the same experiment fails while the first holds the lock.
+- It exits 1 if any run failed.
+
+`labnotes server` doesn't read `.labnotes.toml` yet: pass `--experiments-folder` and `--data-folder`, or set `LABNOTES_EXPERIMENTS_FOLDER` and `LABNOTES_DATA_FOLDER`. The experiments folder has one subfolder per experiment, each with a `design.yaml` and markdown notes. The data folder holds run data and a `.dirsql.toml` declaring a `runs` table with a `study` column.
+
+The run data lives in the data folder. Query it with [dirsql](https://dirsql.dev) and the data folder's `.dirsql.toml`, which declares the `runs` table:
+
+```sh
+uvx dirsql -c data/.dirsql.toml "SELECT * FROM runs LIMIT 1" --format json
+```
+
+`uvx labnotes server` serves the experiments and their runs as a local site.

{labnotes-0.0.13 → labnotes-0.0.15}/src/labnotes/context_guide.py

@@ -16,7 +16,9 @@ def context_guide(config: LabnotesConfig | None, cwd: Path) -> str:
     else:
         project = (
             f"Config: {config.path}\n"
-            f"Experiments folder: {config.experiments_folder}\n"
-            f"Data folder: {config.data_folder}"
+            f"Root: {config.root}\n"
+            f"Experiments: {config.experiments}\n"
+            f"Files: {config.files}\n"
+            f"Runs: {config.runs}"
         )
     return f"labnotes {version('labnotes')}\n\n{project}\n\n{guide}"

labnotes-0.0.15/src/labnotes/default_config_text.py

@@ -0,0 +1,7 @@
+from labnotes.read_path import DEFAULT_PATHS
+
+
+def default_config_text() -> str:
+    return "\n".join(
+        f'[{table}]\npath = "{template}"\n' for table, template in DEFAULT_PATHS.items()
+    )

labnotes-0.0.15/src/labnotes/experiments.py

@@ -0,0 +1,76 @@
+import asyncio
+import sys
+from functools import partial
+from pathlib import Path
+
+import click
+
+from labnotes.load_config import load_config
+from labnotes.print_rows import print_rows
+from labnotes.read_config import CONFIG_FILE
+from labnotes.runner.run_headless import run_headless
+from labnotes.runner.start_experiment import start_experiment
+from labnotes.tables.experiment_rows import experiment_rows
+from labnotes.tui.run_tui import run_tui
+
+
+@click.command(help="List experiments, show one, list its runs, or run it.")
+@click.argument("name", required=False)
+@click.argument("action", required=False, type=click.Choice(["runs", "run"]))
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    show_default=True,
+)
+@click.option(
+    "--concurrency",
+    type=click.IntRange(min=1),
+    default=1,
+    show_default=True,
+    help="With run: how many runs at once.",
+)
+@click.option(
+    "-e",
+    "--experiment-config",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    help="With run: read this file instead of the experiment's experiment.toml.",
+)
+@click.option(
+    "--no-tui",
+    is_flag=True,
+    help="With run: print a line per event instead of the live view.",
+)
+@click.pass_context
+def experiments(
+    ctx: click.Context,
+    name: str | None,
+    action: str | None,
+    output_format: str,
+    concurrency: int,
+    experiment_config: Path | None,
+    no_tui: bool,
+) -> None:
+    config = load_config(ctx)
+    if config is None:
+        raise click.ClickException(
+            f"No {CONFIG_FILE} here. Run labnotes init, or pass -c PATH."
+        )
+    match name, action:
+        case str(), "run":
+            live = sys.stdout.isatty() and sys.stderr.isatty() and not no_tui
+            drive = partial(run_tui, title=name) if live else run_headless
+            try:
+                results = start_experiment(
+                    config, name, experiment_config, concurrency, drive
+                )
+            except ValueError as error:
+                raise click.ClickException(str(error)) from error
+            failed = sum(result["exit_code"] != 0 for result in results)
+            click.echo(f"{len(results) - failed} passed, {failed} failed.")
+            ctx.exit(1 if failed else 0)
+    rows = asyncio.run(experiment_rows(config, name, action))
+    if rows is None:
+        raise click.ClickException(f"No experiment named {name}.")
+    print_rows(rows, output_format)

labnotes-0.0.15/src/labnotes/init.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+import click
+
+from labnotes.default_config_text import default_config_text
+from labnotes.read_config import CONFIG_FILE
+
+
+@click.command(help=f"Write a {CONFIG_FILE} with the default layout here.")
+def init() -> None:
+    path = Path.cwd() / CONFIG_FILE
+    try:
+        with path.open("x", encoding="utf-8") as file:
+            file.write(default_config_text())
+    except FileExistsError as error:
+        raise click.ClickException(f"{path} already exists.") from error
+    click.echo(f"Wrote {path}")

labnotes-0.0.15/src/labnotes/models.py

@@ -0,0 +1,32 @@
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+Report = Callable[[dict[str, object]], None]
+Listen = Callable[[Callable[[], None]], None]
+Start = Callable[[Report, Listen], Coroutine[Any, Any, list[dict[str, object]]]]
+
+
+@dataclass(frozen=True)
+class RunView:
+    sort: str | None = None
+    descending: bool = False
+    status: str | None = None
+    filters: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class LabnotesConfig:
+    path: Path
+    root: Path
+    experiments: str
+    files: str
+    runs: str
+
+
+@dataclass(frozen=True)
+class ExperimentConfig:
+    command: str
+    repeats: int
+    params: dict[str, list[object]]

labnotes-0.0.15/src/labnotes/print_rows.py

@@ -0,0 +1,19 @@
+import json
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+
+def print_rows(rows: list[dict[str, object]], output_format: str) -> None:
+    match output_format:
+        case "json":
+            click.echo(json.dumps(rows, indent=2))
+            return
+    if not rows:
+        click.echo("No rows.")
+        return
+    table = Table(*rows[0].keys())
+    for row in rows:
+        table.add_row(*("" if value is None else str(value) for value in row.values()))
+    Console().print(table)

labnotes-0.0.15/src/labnotes/read_config.py

@@ -0,0 +1,27 @@
+import tomllib
+from pathlib import Path
+
+from labnotes.models import LabnotesConfig
+from labnotes.read_path import DEFAULT_PATHS, read_path
+
+CONFIG_FILE = ".labnotes.toml"
+
+
+def read_config(path: Path) -> LabnotesConfig:
+    try:
+        with path.open("rb") as file:
+            values = tomllib.load(file)
+    except tomllib.TOMLDecodeError as error:
+        raise ValueError(f"{path}: {error}") from error
+    unknown = sorted(values.keys() - DEFAULT_PATHS.keys())
+    if unknown:
+        raise ValueError(f"{path}: unknown tables {', '.join(unknown)}")
+    path = path.resolve()
+    return LabnotesConfig(
+        path,
+        path.parent,
+        **{
+            table: read_path(path, table, values.get(table, {}))
+            for table in DEFAULT_PATHS
+        },
+    )

labnotes-0.0.15/src/labnotes/read_path.py

@@ -0,0 +1,34 @@
+import re
+from pathlib import Path, PurePosixPath
+
+DEFAULT_PATHS = {
+    "experiments": "{experiment}",
+    "files": "{experiment}/files/",
+    "runs": "{experiment}/runs/{run}",
+}
+PLACEHOLDERS = {
+    "experiments": {"experiment"},
+    "files": {"experiment"},
+    "runs": {"experiment", "run"},
+}
+PLACEHOLDER = re.compile(r"\{([^}]*)\}")
+
+
+def read_path(config: Path, table: str, section: object) -> str:
+    if not isinstance(section, dict):
+        raise ValueError(f"{config}: {table} must be a table, like [{table}]")
+    unknown = sorted(section.keys() - {"path"})
+    if unknown:
+        raise ValueError(f"{config}: unknown keys in [{table}]: {', '.join(unknown)}")
+    template = section.get("path", DEFAULT_PATHS[table])
+    if not isinstance(template, str):
+        raise ValueError(f"{config}: [{table}] path must be a string")
+    if PurePosixPath(template).is_absolute() or template.startswith("~"):
+        raise ValueError(
+            f"{config}: [{table}] path must be relative to the config's folder"
+        )
+    required = PLACEHOLDERS[table]
+    if set(PLACEHOLDER.findall(template)) != required:
+        expected = " and ".join(f"{{{name}}}" for name in sorted(required))
+        raise ValueError(f"{config}: [{table}] path must use exactly {expected}")
+    return template

labnotes-0.0.15/src/labnotes/runner/describe_event.py

@@ -0,0 +1,17 @@
+from labnotes.runner.param_args import param_args
+
+
+def describe_event(event: dict[str, object]) -> str:
+    match event["event"]:
+        case "planned":
+            return f"{event['runs']} runs to go, {event['concurrency']} at a time."
+        case "started":
+            args = " ".join(param_args(event["params"]))  # type: ignore[arg-type]
+            return f"{event['run']} started {args}".rstrip()
+        case "ended":
+            outcome = event["error"] or f"exited {event['exit_code']}"
+            return f"{event['run']} {outcome}"
+        case "stopping":
+            return "Stopping runs. Ctrl-C again to kill them."
+        case _:
+            return "Killing runs."