labnotes 0.0.137__tar.gz → 0.1.0__tar.gz

{labnotes-0.0.137 → labnotes-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labnotes
-Version: 0.0.137
+Version: 0.1.0
 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>
@@ -122,13 +122,12 @@ line per event instead.
 - `-e PATH` reads another file instead of `experiment.toml`.
 - `--PARAM=VALUE` runs only the cells where that param has that value, like
   `--model=small`.
-- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) leaves them
-  running. `s` stops the running scripts and records their end, then kills any
-  still going 5 seconds later. Escape goes back. SIGTERM stops them like `s`.
-- A second `run` of the same experiment fails with "already running" while the
-  daemon still has the first going.
-- It exits 0 even if runs fail; the summary line counts failures. If it can't
-  start or reach the daemon, it prints the cause on one line and exits 1.
+- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) stops the running scripts and records their end,
+  then kills any still going 5 seconds later. Escape goes back. SIGTERM and
+  SIGHUP stop them the same way.
+- The foreground process schedules the next run when a slot frees. Closing
+  its terminal stops the runs. Agents should use a dedicated tmux window.
+- It exits 0 even if runs fail; the summary line counts failures.
 
 `labnotes server` serves a local site at http://127.0.0.1:8000 from the same
 `.labnotes.toml`: a table of experiments, and a page per experiment with its

{labnotes-0.0.137 → labnotes-0.1.0}/README.md

@@ -97,13 +97,12 @@ line per event instead.
 - `-e PATH` reads another file instead of `experiment.toml`.
 - `--PARAM=VALUE` runs only the cells where that param has that value, like
   `--model=small`.
-- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) leaves them
-  running. `s` stops the running scripts and records their end, then kills any
-  still going 5 seconds later. Escape goes back. SIGTERM stops them like `s`.
-- A second `run` of the same experiment fails with "already running" while the
-  daemon still has the first going.
-- It exits 0 even if runs fail; the summary line counts failures. If it can't
-  start or reach the daemon, it prints the cause on one line and exits 1.
+- With runs going, Ctrl-C asks first. Enter (or a second Ctrl-C) stops the running scripts and records their end,
+  then kills any still going 5 seconds later. Escape goes back. SIGTERM and
+  SIGHUP stop them the same way.
+- The foreground process schedules the next run when a slot frees. Closing
+  its terminal stops the runs. Agents should use a dedicated tmux window.
+- It exits 0 even if runs fail; the summary line counts failures.
 
 `labnotes server` serves a local site at http://127.0.0.1:8000 from the same
 `.labnotes.toml`: a table of experiments, and a page per experiment with its

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/cli.py

@@ -3,12 +3,10 @@ from pathlib import Path
 import click
 
 from labnotes.context_guide import context_guide
-from labnotes.daemon_command import daemon_command
 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.run_command import run_command
 from labnotes.server import server
 
 
@@ -39,8 +37,6 @@ def context(ctx: click.Context) -> None:
     click.echo(context_guide(load_config(ctx), Path.cwd()), nl=False)
 
 
-main.add_command(daemon_command)
 main.add_command(experiments)
 main.add_command(init)
-main.add_command(run_command)
 main.add_command(server)

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/context.md

@@ -85,7 +85,7 @@ run folder. `command` is the shell command the run executed, with the placeholde
 and the params filled in, written before the run starts, so a killed run has it
 and a later edit to `experiment.toml` doesn't hide what a run did. `ended_by` is `"timeout"`, `"stop"` (labnotes stopped it),
 `"signal"` (a signal labnotes didn't send, like the out-of-memory killer),
-`"lost"` (its process died unseen; the daemon marks these when it starts, with
+`"lost"` (its process died unseen; the next run marks these when it starts, with
 `ended` set and `exit_code` null) or null (the script exited itself). `signal` is the signal number read from the
 exit code (negative, or 128 + N from the shell), else null.
 `git` is `{"commit": "<full HEAD SHA>", "dirty": false}`, read from the command's
@@ -157,10 +157,10 @@ adding a repeat. When the retries run out, the last run keeps exit 75: it never
 got to test its params, so treat it as blocked, not as a result. Stopping the
 runs, or `x` on a run waiting to retry, cancels the retry. A run that was stopped never retries. The live view
 shows a waiting retry as `retry in 30s` and the end as `gave up (exit 75)`;
-`run status --json` reports `retrying`, `retried`, `gave up` and
+The live view reports `retrying`, `retried`, `gave up` and
 `retry cancelled` events.
 
-Runs can take a long time. Start `run` in the background, then check on it with `labnotes experiments foo runs --format json`; a run with no `ended` is still going. Each run lists `size`, the bytes in its run folder, and a running run lists `memory`, the resident bytes of its command and everything it started.
+Runs can take a long time. Start `run` in a dedicated tmux window, then check on it with `labnotes experiments foo runs --format json`; a run with no `ended` is still going. Each run lists `size`, the bytes in its run folder, and a running run lists `memory`, the resident bytes of its command and everything it started.
 
 While a run goes, labnotes appends a memory sample to `memory.jsonl` in its run
 folder every 5 seconds: one JSON line, `{"time": <unix seconds>, "rss": <bytes>,
@@ -202,33 +202,17 @@ going. Elsewhere, it prints a line per event instead.
   `run.json` gets `"error": "timed out after ..."` and `"ended_by": "timeout"`
   next to its exit code.
   Unset, runs have no time limit.
-- `run` hands its runs to the project's labnotes daemon, starting it if
-  needed, and shows or waits for them. The daemon listens on a socket in
-  `/tmp/labnotes-<uid>/` and exits once nothing is running and no client has
-  been connected for 15 seconds. Runs belong to the daemon, so quitting the
-  live view, closing its terminal, or killing `run` outright leaves them going.
-- Each labnotes version starts its own daemon. After an upgrade, new runs go
-  to the new version's daemon while an older one finishes its runs and exits.
-  `run status`, `run stop` and `run control` reach only the daemon of the
-  version you call them with. Each `run` reads `.labnotes.toml` as it is on
-  disk, even when the daemon is already up.
-- Ctrl-C stops the running scripts and records their end. A second Ctrl-C
-  kills them. SIGTERM stops them the same way, then kills any still going 5
-  seconds later. Once the runs are done, either one closes the live view.
-- `labnotes run stop` stops every run the daemon has going: SIGTERM, then
-  SIGKILL 5 seconds later.
-- `labnotes run status` prints what the daemon has going, a line per event so
-  far plus the latest line each running run logged and what each running run
-  uses (`usage` events with `--json`). `-f` keeps following, and
-  waits for a daemon when none is up. `--json` prints one JSON object per line.
-  Following doesn't keep the daemon up.
-- `labnotes run control NAME ACTION [ARG]` sends one live-view control to a
-  running experiment: `kill` a run, `set_concurrency` to a number,
-  `interrupt` or `finish`.
-- A second `run` of the same experiment fails while the first is going on
-  the same daemon.
+- `run` owns its runs in the foreground. In a terminal it shows a live table;
+  outside a terminal it prints events until every run ends. A free concurrency
+  slot starts the next planned run. Agents should start it in a dedicated tmux
+  window so it can keep running between turns.
+- Ctrl-C, SIGTERM, SIGHUP, or quitting the live view stops running scripts:
+  SIGTERM first, then SIGKILL after 5 seconds if needed. Runs are recorded
+  as stopped before labnotes exits. The next start marks unfinished records
+  whose processes are gone as lost.
+- A second invocation starts its own run session and reads the current config.
 - It exits 0 even if runs fail; the summary line counts failures. A run that
   was retried counts as retried, not failed. If it can't
-  start or reach the daemon, it prints the cause on one line and exits 1.
+  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.

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/experiments.py

@@ -5,7 +5,7 @@ from pathlib import Path
 import click
 
 from labnotes.create_experiment import create_experiment
-from labnotes.daemon.remote_start import remote_start
+from labnotes.runner.start_experiment import start_experiment
 from labnotes.utils.format_bytes import format_bytes
 from labnotes.load_config import load_config
 from labnotes.parse_subset import parse_subset
@@ -109,7 +109,7 @@ def experiments(
                 only = parse_subset(ctx.args)
             except ValueError as error:
                 raise click.UsageError(str(error)) from error
-            start = remote_start(
+            start = start_experiment(
                 config,
                 name,
                 experiment_config,

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/load_experiment.py

@@ -8,7 +8,6 @@ from dirsql import DirSQL
 from labnotes.check_counts import check_counts
 from labnotes.count_groups import count_groups
 from labnotes.count_runs import count_runs
-from labnotes.daemon.daemon_running import daemon_running
 from labnotes.experiment_notes import experiment_notes
 from labnotes.experiment_runs import experiment_runs
 from labnotes.format_value import format_value
@@ -24,6 +23,7 @@ from labnotes.runs_view_command import runs_view_command
 from labnotes.sort_href import sort_href
 from labnotes.sql_quote import quote_string
 from labnotes.summarize_config import summarize_config
+from labnotes.utils.process_alive import process_alive
 
 
 def _no_outputs(note: str, content: str) -> Sequence[str]:
@@ -60,6 +60,18 @@ async def load_experiment(
     [totals] = await count_runs(tables, source, str(summary["completed_run"]))
     notes = await experiment_notes(tables, root, name)
     runs = await list_runs(tables, source, str(summary["completed_run"]), view)
+
+    def is_running(row: dict[str, object]) -> bool:
+        record = row.get("run")
+        if not row.get("labnotes_unfinished") or not isinstance(record, str):
+            return False
+        fields = json.loads(record)
+        pid, created = fields.get("pid"), fields.get("pid_created")
+        return isinstance(pid, int) and process_alive(
+            pid, created if isinstance(created, int | float) else None
+        )
+
+    runs_live = any(is_running(run) for run in runs)
     nested = summary["mode"] == "adhoc" and await nests_runs(tables, source)
     groups = (
         group_runs(runs, list(choices), await count_groups(tables, source))
@@ -98,7 +110,7 @@ async def load_experiment(
             for note in notes
         ],
         "runs_list": runs,
-        "runs_live": await daemon_running(root),
+        "runs_live": runs_live,
         "run_groups": groups,
         "run_grid": grid,
         "run_columns": shown,

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/runner/execute_run.py

@@ -38,6 +38,7 @@ async def execute_run(
     state_file: Path,
     memory_interval: float,
     environment: dict[str, str] | None = None,
+    git_info: dict[str, str | bool] | None = None,
 ) -> dict[str, object]:
     resolved = shell_command(command, folder, params, args)
     run: dict[str, object] = {
@@ -49,7 +50,9 @@ async def execute_run(
         "error": None,
         "ended_by": None,
         "signal": None,
-        "git": await asyncio.to_thread(run_git, root),
+        "git": git_info
+        if git_info is not None
+        else await asyncio.to_thread(run_git, root),
     }
     if args:
         run["args"] = list(args)

labnotes-0.1.0/src/labnotes/runner/project_snapshot.py

@@ -0,0 +1,118 @@
+import logging
+import os
+import signal
+import shutil
+import subprocess
+from contextlib import contextmanager
+from collections.abc import Callable
+from dataclasses import dataclass
+from collections.abc import Iterator
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import FrameType
+
+
+@dataclass
+class ProjectSnapshot:
+    root: Path
+    sha: str | None = None
+    diff: bytes | None = None
+
+
+def git(root: Path, *args: str) -> bytes:
+    return subprocess.check_output(["git", *args], cwd=root, stderr=subprocess.DEVNULL)
+
+
+@contextmanager
+def project_snapshot(root: Path) -> Iterator[ProjectSnapshot]:
+    """Capture the working tree once for all commands in an invocation."""
+    try:
+        git(root, "rev-parse", "--is-inside-work-tree")
+    except (OSError, subprocess.SubprocessError):
+        logging.warning("Project is not a git repository; running from the live tree")
+        yield ProjectSnapshot(root)
+        return
+
+    try:
+        sha = git(root, "rev-parse", "HEAD").decode("ascii").strip()
+        diff = git(root, "diff", "HEAD")
+    except (OSError, subprocess.SubprocessError):
+        logging.warning("Project has no readable Git HEAD; running from the live tree")
+        yield ProjectSnapshot(root)
+        return
+    files = filter(
+        None, git(root, "ls-files", "-co", "--exclude-standard", "-z").split(b"\0")
+    )
+    ignored = filter(
+        None,
+        git(root, "ls-files", "-oi", "--exclude-standard", "--directory", "-z").split(
+            b"\0"
+        ),
+    )
+    with TemporaryDirectory(prefix="labnotes-") as directory:
+        snapshot = Path(directory)
+        previous: dict[
+            signal.Signals,
+            Callable[[int, FrameType | None], object] | int | signal.Handlers | None,
+        ] = {}
+
+        def stop(_number: int, _frame: object) -> None:
+            raise KeyboardInterrupt
+
+        try:
+            for number in (signal.SIGTERM, signal.SIGHUP):
+                try:
+                    old_handler = signal.signal(number, stop)
+                except ValueError:
+                    break  # Signals can only be installed from the main thread.
+                previous[number] = old_handler
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--quiet",
+                    "--shared",
+                    "--no-checkout",
+                    str(root),
+                    str(snapshot),
+                ],
+                check=True,
+            )
+            for raw in files:
+                relative = Path(raw.decode())
+                source = root / relative
+                if not source.exists() and not source.is_symlink():
+                    continue
+                target = snapshot / relative
+                target.parent.mkdir(parents=True, exist_ok=True)
+                if source.is_symlink():
+                    target.symlink_to(
+                        os.readlink(source), target_is_directory=source.is_dir()
+                    )
+                elif source.is_dir():
+                    shutil.copytree(source, target, symlinks=True)
+                else:
+                    shutil.copy2(source, target)
+            skipped: set[Path] = set()
+            for raw in ignored:
+                relative = Path(raw.decode().rstrip("/"))
+                if any(parent in relative.parents for parent in skipped):
+                    continue
+                if any((snapshot / parent).is_symlink() for parent in relative.parents):
+                    continue
+                source = root / relative
+                if source.is_dir() and (source / "pyvenv.cfg").exists():
+                    skipped.add(relative)
+                    continue
+                target = snapshot / relative
+                if target.is_symlink() or target.exists():
+                    continue
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.symlink_to(source, target_is_directory=source.is_dir())
+            subprocess.run(
+                ["git", "-C", str(snapshot), "reset", "--quiet", sha], check=True
+            )
+        finally:
+            for number, handler in previous.items():
+                signal.signal(number, handler)
+        yield ProjectSnapshot(snapshot, sha, diff)

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/runner/run_experiment.py

@@ -27,6 +27,7 @@ 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.plan_runs import plan_runs
+from labnotes.runner.project_snapshot import ProjectSnapshot
 from labnotes.runner.run_folder import run_folder
 from labnotes.runner.signal_tree import signal_tree
 from labnotes.state_path import STATE_ENV
@@ -49,7 +50,9 @@ async def run_experiment(
     only: dict[str, str] | None = None,
     args: list[str] | None = None,
     environment: dict[str, str] | None = None,
+    snapshot: ProjectSnapshot | None = None,
 ) -> list[dict[str, object]]:
+    command_root = snapshot.root if snapshot is not None else config.root
     inherited = dict(os.environ) if environment is None else environment
     tables = open_tables(config)
     existing = await experiment_run_ids(tables, name)
@@ -109,7 +112,7 @@ async def run_experiment(
     meta = None
     if experiment.meta is not None:
         meta = await invocation_meta(
-            config.root, fill_dirs(experiment.meta, dirs), hook_env["meta"]
+            command_root, fill_dirs(experiment.meta, dirs), hook_env["meta"]
         )
     if dirs:
         Path(dirs["invocation_dir"]).mkdir(parents=True, exist_ok=True)
@@ -242,12 +245,15 @@ async def run_experiment(
     async def start(run: str, params: dict[str, object]) -> None:
         folder = run_folder(config.root, config.runs, name, run)
         folder.mkdir(parents=True, exist_ok=True)
+        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 = dirs.get("invocation_dir") or str(folder.resolve())
         report({"event": "started", "run": run, "params": params, "folder": folder})
         running[run] = set()
         trees[run] = set()
         result = await execute_run(
-            config.root,
+            command_root,
             folder,
             fill_dirs(
                 experiment.command,
@@ -276,6 +282,11 @@ async def run_experiment(
                     "invocation_dir": run_invocation_dir,
                 },
             ),
+            git_info=(
+                {"commit": snapshot.sha, "dirty": bool(snapshot.diff)}
+                if snapshot is not None and snapshot.sha is not None
+                else None
+            ),
         )
         del running[run], trees[run]
         report({"event": "ended", "run": run, **result})
@@ -290,7 +301,7 @@ async def run_experiment(
         if experiment.teardown is not None:
             report({"event": "tearing down"})
             await invocation_hook(
-                config.root,
+                command_root,
                 "teardown",
                 fill_dirs(experiment.teardown, dirs),
                 hook_env["teardown"],
@@ -311,7 +322,7 @@ async def run_experiment(
             if experiment.setup is not None:
                 report({"event": "setting up"})
                 await invocation_hook(
-                    config.root,
+                    command_root,
                     "setup",
                     fill_dirs(experiment.setup, dirs),
                     hook_env["setup"],

labnotes-0.1.0/src/labnotes/runner/start_experiment.py

@@ -0,0 +1,40 @@
+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.prepare_experiment import prepare_experiment
+from labnotes.runner.project_snapshot import project_snapshot
+from labnotes.runner.run_experiment import run_experiment
+
+
+def start_experiment(
+    config: LabnotesConfig,
+    name: str,
+    experiment_config: Path | None,
+    concurrency: int | None,
+    timeout: int | None,
+    only: dict[str, str] | None,
+    args: list[str] | None,
+    setup: str | None,
+    teardown: str | None,
+) -> Start:
+    async def start(report: Report, listen: Listen) -> list[dict[str, object]]:
+        experiment, limit = await prepare_experiment(
+            config, name, experiment_config, concurrency, only, args, setup, teardown
+        )
+        await finalize_lost_runs(config)
+        with project_snapshot(config.root) as snapshot:
+            return await run_experiment(
+                config,
+                name,
+                experiment,
+                limit,
+                report,
+                listen,
+                timeout=timeout,
+                only=only,
+                args=args,
+                snapshot=snapshot,
+            )
+
+    return start

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/tui/leave_prompt.py

@@ -10,8 +10,7 @@ class LeavePrompt(ModalScreen[str | None]):
     #prompt { width: auto; padding: 1 2; border: round $accent; }
     """
     BINDINGS = [
-        Binding("enter,ctrl+c", "dismiss('leave')", "Leave running"),
-        Binding("s", "dismiss('stop')", "Stop them"),
+        Binding("enter,ctrl+c,s", "dismiss('stop')", "Stop runs"),
         Binding("escape", "dismiss", "Cancel"),
     ]
 
@@ -23,6 +22,6 @@ class LeavePrompt(ModalScreen[str | None]):
         runs = "run" if self.count == 1 else "runs"
         yield Static(
             f"{self.count} {runs} still going. "
-            "Leave them running (enter) / stop them (s) / cancel (esc).",
+            "Stop them (enter or s) / cancel (esc).",
             id="prompt",
         )

{labnotes-0.0.137 → labnotes-0.1.0}/src/labnotes/tui/run_app.py

@@ -1,4 +1,3 @@
-import asyncio
 import signal
 import time
 from collections.abc import Sequence
@@ -100,7 +99,7 @@ class RunApp(App[None]):
     def listen(self, controls: Controls) -> None:
         self.controls = controls
         stop_then_kill(self.stop_runs, signal.SIGTERM)
-        asyncio.get_running_loop().add_signal_handler(signal.SIGHUP, self.exit)
+        stop_then_kill(self.stop_runs, signal.SIGHUP)
 
     def show_event(self, event: dict[str, object]) -> None:
         table = self.query_one(DataTable)
@@ -286,9 +285,7 @@ class RunApp(App[None]):
         self.action_interrupt()
 
     def answer(self, choice: str | None) -> None:
-        if choice == "leave":
-            self.exit()
-        elif choice == "stop":
+        if choice == "stop":
             self.controls.interrupt()
             self.set_timer(GRACE_SECONDS, self.controls.interrupt)
 

{labnotes-0.0.137 → labnotes-0.1.0}/testing-conventions.toml

@@ -1,9 +1,3 @@
-[[python.exempt]]
-path = "src/labnotes/runner/hold_folder.py"
-rules = ["mutation"]
-lines = [12]
-reason = "LOCK_EX and LOCK_NB are disjoint bits, so | equals + and ^"
-
 [[python.exempt]]
 path = "src/labnotes/tui/run_output.py"
 rules = ["mutation"]
@@ -16,30 +10,6 @@ rules = ["mutation"]
 lines = [61, 69]
 reason = "summarize_config returns mode matrix or adhoc; \"matrix\" <= \"adhoc\" is false like ==, and both are interned literals so is equals =="
 
-[[python.exempt]]
-path = "src/labnotes/daemon/exit_when_idle.py"
-rules = ["mutation"]
-lines = [12]
-reason = "quiet counts up by one from zero, so it reaches IDLE_EXIT_SECONDS before passing it: < equals != and, for small ints, is not"
-
-[[python.exempt]]
-path = "src/labnotes/daemon/daemon_app.py"
-rules = ["mutation"]
-lines = [134]
-reason = "start answers 202, 400, 409 or 500, so every status but 202 is above it: != equals >"
-
-[[python.exempt]]
-path = "src/labnotes/daemon/remote_start.py"
-rules = ["mutation"]
-lines = [51]
-reason = "the daemon answers a run with 202, 400, 409 or 500, so every status but 202 is above it: != equals >"
-
-[[python.exempt]]
-path = "src/labnotes/run_control.py"
-rules = ["mutation"]
-lines = [39]
-reason = "argument counts are small ints, which CPython caches, so is not equals !="
-
 [[python.exempt]]
 path = "src/labnotes/tui/run_cells.py"
 rules = ["mutation"]

{labnotes-0.0.137 → labnotes-0.1.0}/tests/integration/conftest.py

@@ -10,7 +10,6 @@ from pathlib import Path
 import pytest
 from playwright.async_api import Page, async_playwright
 
-from labnotes.daemon.socket_path import socket_path
 
 CONFIG = (
     'name = "Alpha study"\ncommand = "go"\nrepeats = 2\nmode = "matrix"\n'
@@ -45,24 +44,6 @@ def free_port() -> int:
         return int(sock.getsockname()[1])
 
 
-def daemon(root: Path) -> Iterator[None]:
-    labnotes = Path(sys.executable).parent / "labnotes"
-    process = subprocess.Popen(
-        [labnotes, "-c", root / ".labnotes.toml", "daemon"],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    try:
-        for _ in range(100):
-            if socket_path(root).exists():
-                break
-            time.sleep(0.1)
-        yield
-    finally:
-        process.terminate()
-        process.wait()
-
-
 def serve(root: Path) -> Iterator[str]:
     port = free_port()
     labnotes = Path(sys.executable).parent / "labnotes"

{labnotes-0.0.137 → labnotes-0.1.0}/uv.lock

@@ -385,20 +385,20 @@ wheels = [
 
 [[package]]
 name = "httpcore2"
-version = "2.13.1"
+version = "2.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "h11" },
     { name = "truststore" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cb/f3/1db7aa2bc2524062192bb0e0323969492d1883152a232fe36eea65f4e35c/httpcore2-2.13.1.tar.gz", hash = "sha256:e0aa977abe17e69a3b820a24542a6fa88702676d83880b8d194dcd18408e5103", size = 68071, upload-time = "2026-09-23T07:47:22.372Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/61/afa9d6b7452f9eca73f73d45324eb0bb52f098fd5e6049bf6b8263be9b4e/httpcore2-2.16.0.tar.gz", hash = "sha256:c72cd0413563b17e1cd8354677dff887466f8ec2551679759e93126534428643", size = 69886, upload-time = "2026-10-21T07:09:45.31Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/09/ba/a4568248771ce81957bfb7cc600264a40fbcda092391ee1c415c50be4bea/httpcore2-2.13.1-py3-none-any.whl", hash = "sha256:e1e05d4f25f7d7d496bfb96748f6f4b67657b03da069b3a68c36069f3db73d0a", size = 83423, upload-time = "2026-09-23T07:47:19.365Z" },
+    { url = "https://files.pythonhosted.org/packages/af/c2/ce417c397afa5181f0e3c6ff01a4d01639414e1adef08730d97571297151/httpcore2-2.16.0-py3-none-any.whl", hash = "sha256:5c4358319f2602d984ad93182c9fee5160f22e9da7babdda870a5e7c4e2dc34f", size = 85070, upload-time = "2026-10-21T07:09:42.802Z" },
 ]
 
 [[package]]
 name = "httpx2"
-version = "2.13.1"
+version = "2.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio", marker = "sys_platform != 'emscripten'" },
@@ -408,9 +408,9 @@ dependencies = [
     { name = "truststore", marker = "sys_platform != 'emscripten'" },
     { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d5/44/474bef2a0e9d90f1715d32cb98b0738695ca17ba324095fb2497ed7fbd59/httpx2-2.13.1.tar.gz", hash = "sha256:e48744a19e3af5ee48313d0ce5fe941d5422fae5705ea922a4aabf94d7800dfa", size = 100405, upload-time = "2026-09-23T07:47:23.052Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/73/5ca2cedf5e4e50423d1c258877865a6b62793633b561c58499f8aeb33b7e/httpx2-2.16.0.tar.gz", hash = "sha256:0d54c98128e8f2ff7fbbde0fca8c359e5f032edeaaaac443cdb7f31f685bcd7f", size = 103116, upload-time = "2026-10-21T07:09:46.348Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d8/9c/6fe8931fd9f381042a9e4c7d5a7b4cbf7016b252bec0c99a49fce42c3326/httpx2-2.13.1-py3-none-any.whl", hash = "sha256:6dff50fabc270ee5fd25d845d0b078ed20564579744d6d962850975996d2f9a4", size = 95597, upload-time = "2026-09-23T07:47:20.995Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/3d/2e4bc4fd1ef9770871669adb348d612a6e4786b303a23f9935b81c48dd60/httpx2-2.16.0-py3-none-any.whl", hash = "sha256:fd2c5d7909e8d86fe92d53020c310ca0e4e431b838c207c5754b9bbf0308d49a", size = 97880, upload-time = "2026-10-21T07:09:44.01Z" },
 ]
 
 [[package]]

labnotes-0.0.137/src/labnotes/daemon/control_run.py

@@ -1,16 +0,0 @@
-from pathlib import Path
-
-from labnotes.daemon.daemon_client import daemon_client
-from labnotes.daemon.daemon_running import daemon_running
-
-
-async def control_run(
-    root: Path, name: str, action: str, args: list[object]
-) -> str | None:
-    if not await daemon_running(root):
-        return "Nothing is running."
-    async with daemon_client(root) as client:
-        reply = await client.post(f"/experiments/{name}/{action}", json={"args": args})
-    if reply.is_success:
-        return None
-    return str(reply.json()["error"])