GeezerVison

why: the EngineOpsWorkspaceBuilder consumes libtmux's unreleased
experimental workspace API (analyze/Workspace.abuild/WorkspaceSet,
AsyncSubprocessEngine.for_server). This branch-only [tool.uv.sources]
pin makes it importable; not for release.

what:
- Add [tool.uv.sources] libtmux -> engine-ops git branch
- uv lock

why: the classic builder issues one libtmux call per window/pane/command.
libtmux's engine-ops workspace API folds a whole session into a handful of
;-chained tmux dispatches and builds it asynchronously; wiring it as an
opt-in builder gives tmuxp that speedup without touching the classic path.

what:
- Add EngineOpsWorkspaceBuilder (WorkspaceBuilderProtocol): analyze the
  config to a Workspace, abuild it over AsyncSubprocessEngine.for_server,
  bridge BuildEvents to on_build_event, populate .session
- Register the `engine-ops` entry point (select via workspace_builder key)
- Cover build shape, protocol conformance, entry-point resolution, event
  forwarding, and the append/empty guards

why: Let users route a single load through the async folding
builder from the command line, without editing the workspace
file's workspace_builder key.

what:
- Add --engine-ops flag to `tmuxp load` (CLILoadNamespace field,
  argparse switch, command_load pass-through)
- load_workspace() gains builder_override= to inject the
  workspace_builder key after expansion
- Enrich the builder's session_created event with name,
  window_total and session_pane_total so the load spinner
  renders instead of raising KeyError
- Add a CLI-flag build test

why: Build several workspaces as one folded engine-ops set so N
sessions render in a few ;-chained tmux dispatches sharing one
preflight, instead of one detached load per file.

what:
- Add _load_parallel(): lower each file to the Workspace IR, group
  into a WorkspaceSet, and abuild the compiled plan
- Add --parallel (implies engine-ops), --dry-run (print the
  compiled plan without building) and --no-fold (SequentialPlanner)
- Reject -a/--append and -s; require --parallel for --dry-run and
  --no-fold; surface duplicate-name and on_exists errors
- Attach the last declared session unless detached
- Add CLI tests for build shape, dry-run, dup names and flag guards

why: Turn one parameterized workspace file into a session per
value -- a matrix over multiple axes -- reusing the folded set
build instead of copy-pasting near-identical workspace files.

what:
- Add --expand KEY=V1,V2 (repeatable) to expand a single file over
  variants, substituting $KEY placeholders via expand()
- Add _parse_expand_specs(): parse specs into a Cartesian product
  of variant dicts; reject malformed specs
- Route --expand through the set-build path (it implies it) and
  require exactly one workspace file
- Extend the --dry-run/--no-fold guard to accept --expand
- Add unit + live tests for matrix build, substitution, rejections

why: --parallel/--expand skipped all plugins. before_script is a
post-build, whole-session hook the fold already exposes, so running
it costs nothing and restores real plugin value; the mid-build hooks
can't fold and are skipped with a warning instead of silently.

what:
- Load each file's plugins before the fold (keeps the version
  pre-flight gate) and memoize per file so --expand variants that
  share a file load and warn once
- Run before_script on each freshly built session after abuild, in
  the file's import sandbox; a raising hook is logged, not fatal to
  the other built sessions
- Warn once per plugin overriding a mid-build hook
  (before_workspace_builder/on_window_create/after_window_finished)
- Do not fire reattach on fresh set builds, matching a fresh
  sequential load
- Document the contract in the docstring and plugins topic doc
- Add parametrized hook, leniency, and no-load tests

why: The libtmux engine-ops branch advanced (bug fixes + doc hygiene);
re-resolve the pin so this branch builds against the current tip.

why: The libtmux engine-ops branch advanced (supervised reconnect,
drain-restart error fix, reconnect backoff + proc-cleanup hardening,
and the experimental facade->objects package rename), so re-resolve
the git pin to pick it up.

what:
- uv.lock: libtmux engine-ops 4393b02a -> f52b2d3f.

why: --engine-ops hardcoded AsyncSubprocessEngine; the persistent
control-mode engine builds larger workspaces much faster but was not
reachable from the CLI.

what:
- Add --engine-ops-engine {subprocess,control_mode} (default
  subprocess), threaded through the expanded-workspace config key like
  builder_override.
- Select AsyncSubprocessEngine or AsyncControlModeEngine (an async
  context manager) at both build sites: the single builder and the
  --parallel/--expand workspace set.
- Cover both engines with a parametrized build test.

why: Track the latest engine-ops branch tip so the pinned libtmux
matches the branch HEAD used downstream.

what:
- Bump locked libtmux rev f52b2d3f -> be88f08d (scripts-only delta:
  hermetic engine benchmark grid + results)

why: Track the latest engine-ops branch tip so the pinned libtmux
matches the branch HEAD used downstream.

what:
- Bump locked libtmux rev be88f08d -> aa6d822d (scripts-only delta:
  bench_engines mypy fix)

why: Track the latest engine-ops branch tip so the pinned libtmux
matches the branch HEAD used downstream.

what:
- Bump locked libtmux rev aa6d822d -> 1fe8fc67 (ConcreteEngine renamed
  to MockEngine upstream; no downstream code references it)

why: libtmux's engine-ops branch was rebased onto master (absorbing the
gp-sphinx docs-dep bump); the prior pinned commit is now unreachable and
GC-eligible on the remote.

what:
- Bump locked libtmux rev 1fe8fc67 -> e88e87b6

why: libtmux's engine-ops branch advanced -- the engines now hold a
ServerConnection (one owner for the connection flags, tmux-bin
resolution and argv assembly), the chain folder is guarded by
ensure_chainable, shared helpers are imported rather than re-inlined,
and the unread surface is gone.

what:
- Relock libtmux to the current engine-ops tip (22557d98).