pocketshell 0.3.11__tar.gz → 0.3.13__tar.gz

{pocketshell-0.3.11 → pocketshell-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pocketshell
-Version: 0.3.11
+Version: 0.3.13
 Summary: Unified server-side Python utility for the PocketShell Android client.
 Project-URL: Homepage, https://github.com/alexeygrigorev/pocketshell
 Project-URL: Issues, https://github.com/alexeygrigorev/pocketshell/issues

{pocketshell-0.3.11 → pocketshell-0.3.13}/pyproject.toml

@@ -8,7 +8,7 @@ name = "pocketshell"
 # scripts/check-pypi-version.sh enforces this; .github/workflows/build.yml
 # runs that check before publishing to PyPI. See
 # tools/pocketshell/README.md ("Release flow") for the bump procedure.
-version = "0.3.11"
+version = "0.3.13"
 description = "Unified server-side Python utility for the PocketShell Android client."
 readme = "README.md"
 requires-python = ">=3.11"

{pocketshell-0.3.11 → pocketshell-0.3.13}/src/pocketshell/daemon.py

@@ -85,6 +85,12 @@ METHOD_TTLS: Mapping[str, float] = {
     # rarely change minute-to-minute; the longer window keeps the
     # Android picker fast without burning rate-limit quota.
     "repos.list_remote": 300.0,
+    # tmuxctl-backed lists are relatively cheap, but Android may poll
+    # them from dashboards. Keep the window short so daemon-side
+    # mutations can invalidate immediately and external tmux changes are
+    # not hidden for long.
+    "sessions.list": 5.0,
+    "jobs.list": 5.0,
 }
 
 # Length-prefix is a 4-byte unsigned big-endian integer. ``struct``
@@ -460,6 +466,67 @@ def _repos_open_handler(params: Mapping[str, Any]) -> dict[str, Any]:
     return _repos.daemon_handler_open(dict(params))
 
 
+# ---------------------------------------------------------------------------
+# Methods: sessions.* / jobs.*
+# ---------------------------------------------------------------------------
+
+
+def _sessions_list_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``sessions.list`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import sessions as _sessions
+
+    return _sessions.daemon_handler_list(dict(params))
+
+
+def _jobs_list_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.list`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_list(dict(params))
+
+
+def _jobs_show_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.show`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_show(dict(params))
+
+
+def _jobs_trigger_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.trigger`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_trigger(dict(params))
+
+
+def _jobs_add_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.add`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_add(dict(params))
+
+
+def _jobs_edit_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.edit`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_edit(dict(params))
+
+
+def _jobs_remove_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.remove`` to the existing tmuxctl-backed wrapper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_remove(dict(params))
+
+
+def _jobs_status_handler(params: Mapping[str, Any]) -> dict[str, Any]:
+    """Delegate ``jobs.status`` to the scheduler status helper."""
+    from pocketshell import jobs as _jobs
+
+    return _jobs.daemon_handler_status(dict(params))
+
+
 # Single shared registry; tests can register additional methods via
 # :meth:`Daemon.register_method` on a fresh instance without touching
 # this dict.
@@ -469,6 +536,14 @@ DEFAULT_METHODS: Mapping[str, RpcHandler] = {
     "repos.list_remote": _repos_list_remote_handler,
     "repos.clone": _repos_clone_handler,
     "repos.open": _repos_open_handler,
+    "sessions.list": _sessions_list_handler,
+    "jobs.list": _jobs_list_handler,
+    "jobs.show": _jobs_show_handler,
+    "jobs.trigger": _jobs_trigger_handler,
+    "jobs.add": _jobs_add_handler,
+    "jobs.edit": _jobs_edit_handler,
+    "jobs.remove": _jobs_remove_handler,
+    "jobs.status": _jobs_status_handler,
 }
 
 
@@ -485,6 +560,10 @@ DEFAULT_METHODS: Mapping[str, RpcHandler] = {
 # change as soon as a clone lands.
 METHOD_CACHE_INVALIDATIONS: Mapping[str, tuple[str, ...]] = {
     "repos.clone": ("repos.list_local",),
+    "jobs.add": ("jobs.list",),
+    "jobs.edit": ("jobs.list",),
+    "jobs.remove": ("jobs.list",),
+    "jobs.trigger": ("jobs.list",),
 }
 
 

{pocketshell-0.3.11 → pocketshell-0.3.13}/src/pocketshell/jobs.py

@@ -79,7 +79,7 @@ from __future__ import annotations
 import shutil
 import subprocess
 import sys
-from typing import Optional, Sequence
+from typing import Any, Optional, Sequence
 
 import click
 
@@ -146,6 +146,150 @@ def _run_tmuxctl(args: Sequence[str]) -> int:
     return completed.returncode
 
 
+def _run_tmuxctl_capture(args: Sequence[str]) -> dict[str, Any]:
+    """Invoke ``tmuxctl`` and return a daemon-friendly raw envelope."""
+    tmuxctl_path = _resolve_tmuxctl_binary()
+    if tmuxctl_path is None:
+        return {
+            "stdout": "",
+            "stderr": _tmuxctl_missing_message() + "\n",
+            "returncode": 127,
+        }
+
+    completed = subprocess.run(
+        [tmuxctl_path, *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return {
+        "stdout": completed.stdout,
+        "stderr": completed.stderr,
+        "returncode": completed.returncode,
+    }
+
+
+def _emit_envelope(ctx: click.Context, envelope: dict[str, Any]) -> None:
+    """Proxy a daemon/subprocess envelope to stdout/stderr and exit code."""
+    if envelope.get("stdout"):
+        sys.stdout.write(str(envelope["stdout"]))
+    if envelope.get("stderr"):
+        sys.stderr.write(str(envelope["stderr"]))
+    exit_code = int(envelope.get("returncode", 0))
+    if exit_code != 0:
+        ctx.exit(exit_code)
+
+
+def _try_daemon_jobs_call(
+    method: str,
+    params: dict[str, Any],
+    *,
+    timeout: float = 5.0,
+) -> Optional[dict[str, Any]]:
+    """Dispatch a jobs RPC to the daemon; return ``None`` on miss/error."""
+    from pocketshell import daemon as _daemon
+
+    socket_path = _daemon.resolve_socket_path()
+    if not socket_path.exists():
+        return None
+
+    try:
+        result = _daemon.call(
+            method,
+            params=params,
+            socket_path=socket_path,
+            timeout=timeout,
+        )
+    except (_daemon.DaemonClientError, RuntimeError, OSError):
+        return None
+    if not isinstance(result, dict):
+        return None
+    return result
+
+
+def _extra_args(params: dict[str, Any]) -> list[str]:
+    raw = params.get("extra_args")
+    if not isinstance(raw, list):
+        return []
+    return [item for item in raw if isinstance(item, str)]
+
+
+def daemon_handler_list(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.list``."""
+    args: list[str] = ["jobs", "list"]
+    session = params.get("session")
+    if isinstance(session, str) and session:
+        args.extend(["--session", session])
+    args.extend(_extra_args(params))
+    return _run_tmuxctl_capture(args)
+
+
+def daemon_handler_show(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.show``."""
+    job_id = params.get("job_id")
+    args: list[str] = ["jobs", "show", str(job_id)]
+    args.extend(_extra_args(params))
+    return _run_tmuxctl_capture(args)
+
+
+def daemon_handler_trigger(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.trigger``."""
+    job_id = params.get("job_id")
+    args: list[str] = ["jobs", "trigger", str(job_id)]
+    args.extend(_extra_args(params))
+    return _run_tmuxctl_capture(args)
+
+
+def daemon_handler_add(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.add``."""
+    session_name = params.get("session_name")
+    every = params.get("every")
+    args: list[str] = ["jobs", "add", str(session_name), "--every", str(every)]
+    message = params.get("message")
+    if isinstance(message, str):
+        args.extend(["--message", message])
+    if bool(params.get("start_now")):
+        args.append("--start-now")
+    args.extend(_extra_args(params))
+    return _run_tmuxctl_capture(args)
+
+
+def daemon_handler_edit(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.edit``."""
+    job_id = params.get("job_id")
+    args: list[str] = ["jobs", "edit", str(job_id)]
+    session = params.get("session")
+    if isinstance(session, str):
+        args.extend(["--session", session])
+    every = params.get("every")
+    if isinstance(every, str):
+        args.extend(["--every", every])
+    message = params.get("message")
+    if isinstance(message, str):
+        args.extend(["--message", message])
+    if bool(params.get("enable")):
+        args.append("--enable")
+    if bool(params.get("disable")):
+        args.append("--disable")
+    args.extend(_extra_args(params))
+    return _run_tmuxctl_capture(args)
+
+
+def daemon_handler_remove(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.remove``."""
+    job_id = params.get("job_id")
+    args: list[str] = ["jobs", "remove", str(job_id)]
+    args.extend(_extra_args(params))
+    return _run_tmuxctl_capture(args)
+
+
+def daemon_handler_status(_params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``jobs.status``."""
+    if _is_daemon_running():
+        return {"stdout": "running\n", "stderr": "", "returncode": 0}
+    return {"stdout": "not running\n", "stderr": "", "returncode": 3}
+
+
 @click.group(
     name="jobs",
     context_settings={"help_option_names": ["-h", "--help"]},
@@ -191,9 +335,13 @@ def jobs_list(ctx: click.Context, session: Optional[str]) -> None:
     # `ctx.args` holds any extras we ignored (e.g. `--json` once
     # tmuxctl supports it). Forward verbatim, position preserved.
     args.extend(ctx.args)
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    params: dict[str, Any] = {"extra_args": list(ctx.args)}
+    if session:
+        params["session"] = session
+    envelope = _try_daemon_jobs_call("jobs.list", params)
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)
 
 
 @jobs_group.command(
@@ -209,9 +357,13 @@ def jobs_list(ctx: click.Context, session: Optional[str]) -> None:
 def jobs_show(ctx: click.Context, job_id: int) -> None:
     """Show details for one job (delegates to `tmuxctl jobs show`)."""
     args: list[str] = ["jobs", "show", str(job_id), *ctx.args]
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    envelope = _try_daemon_jobs_call(
+        "jobs.show",
+        {"job_id": job_id, "extra_args": list(ctx.args)},
+    )
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)
 
 
 @jobs_group.command(
@@ -234,9 +386,13 @@ def jobs_trigger(ctx: click.Context, job_id: int) -> None:
     brief calls for parity, not a reimplementation.
     """
     args: list[str] = ["jobs", "trigger", str(job_id), *ctx.args]
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    envelope = _try_daemon_jobs_call(
+        "jobs.trigger",
+        {"job_id": job_id, "extra_args": list(ctx.args)},
+    )
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)
 
 
 # ----- jobs add / edit / remove --------------------------------------
@@ -294,9 +450,17 @@ def jobs_add(
     if start_now:
         args.append("--start-now")
     args.extend(ctx.args)
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    params: dict[str, Any] = {
+        "session_name": session_name,
+        "every": every,
+        "message": message,
+        "start_now": start_now,
+        "extra_args": list(ctx.args),
+    }
+    envelope = _try_daemon_jobs_call("jobs.add", params)
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)
 
 
 @jobs_group.command(
@@ -374,9 +538,19 @@ def jobs_edit(
     if disable:
         args.append("--disable")
     args.extend(ctx.args)
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    params = {
+        "job_id": job_id,
+        "session": session,
+        "every": every,
+        "message": message,
+        "enable": enable,
+        "disable": disable,
+        "extra_args": list(ctx.args),
+    }
+    envelope = _try_daemon_jobs_call("jobs.edit", params)
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)
 
 
 @jobs_group.command(
@@ -397,9 +571,13 @@ def jobs_remove(ctx: click.Context, job_id: int) -> None:
     `tmuxctl jobs remove JOB_ID`.
     """
     args: list[str] = ["jobs", "remove", str(job_id), *ctx.args]
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    envelope = _try_daemon_jobs_call(
+        "jobs.remove",
+        {"job_id": job_id, "extra_args": list(ctx.args)},
+    )
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)
 
 
 # ----- daemon subgroup ------------------------------------------------
@@ -493,13 +671,10 @@ def daemon_status(ctx: click.Context) -> None:
     - 0  -> daemon process is alive
     - 3  -> daemon process is NOT running
     """
-    if _is_daemon_running():
-        click.echo("running")
-        return
-    click.echo("not running")
-    # `systemctl is-active` returns 3 for `inactive`; matching that lets
-    # shell-script consumers `&& echo up || echo down` consistently.
-    ctx.exit(3)
+    envelope = _try_daemon_jobs_call("jobs.status", {})
+    if envelope is None:
+        envelope = daemon_handler_status({})
+    _emit_envelope(ctx, envelope)
 
 
 @daemon_group.command("stop")

{pocketshell-0.3.11 → pocketshell-0.3.13}/src/pocketshell/sessions.py

@@ -41,7 +41,7 @@ from __future__ import annotations
 import shutil
 import subprocess
 import sys
-from typing import Optional, Sequence
+from typing import Any, Optional, Sequence
 
 import click
 
@@ -98,6 +98,87 @@ def _run_tmuxctl(args: Sequence[str]) -> int:
     return completed.returncode
 
 
+def _run_tmuxctl_capture(args: Sequence[str]) -> dict[str, Any]:
+    """Invoke ``tmuxctl`` and return a daemon-friendly raw envelope."""
+    tmuxctl_path = _resolve_tmuxctl_binary()
+    if tmuxctl_path is None:
+        return {
+            "stdout": "",
+            "stderr": _tmuxctl_missing_message() + "\n",
+            "returncode": 127,
+        }
+
+    completed = subprocess.run(
+        [tmuxctl_path, *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return {
+        "stdout": completed.stdout,
+        "stderr": completed.stderr,
+        "returncode": completed.returncode,
+    }
+
+
+def _emit_envelope(ctx: click.Context, envelope: dict[str, Any]) -> None:
+    """Proxy a daemon/subprocess envelope to stdout/stderr and exit code."""
+    if envelope.get("stdout"):
+        sys.stdout.write(str(envelope["stdout"]))
+    if envelope.get("stderr"):
+        sys.stderr.write(str(envelope["stderr"]))
+    exit_code = int(envelope.get("returncode", 0))
+    if exit_code != 0:
+        ctx.exit(exit_code)
+
+
+def _try_daemon_sessions_list(
+    *,
+    sort_by: Optional[str],
+    extra_args: Sequence[str],
+) -> Optional[dict[str, Any]]:
+    """Dispatch ``sessions.list`` to the daemon; return ``None`` on miss."""
+    from pocketshell import daemon as _daemon
+
+    socket_path = _daemon.resolve_socket_path()
+    if not socket_path.exists():
+        return None
+
+    params: dict[str, Any] = {"extra_args": list(extra_args)}
+    if sort_by:
+        params["sort_by"] = sort_by
+
+    try:
+        result = _daemon.call(
+            "sessions.list",
+            params=params,
+            socket_path=socket_path,
+            timeout=5.0,
+        )
+    except (_daemon.DaemonClientError, RuntimeError, OSError):
+        return None
+    if not isinstance(result, dict):
+        return None
+    return result
+
+
+def daemon_handler_list(params: dict[str, Any]) -> dict[str, Any]:
+    """JSON-RPC handler for ``sessions.list``.
+
+    Returns the same raw stdout/stderr/returncode envelope as the
+    one-shot subprocess path so the CLI can preserve byte-identical
+    output while moving the process spawn into the daemon.
+    """
+    args: list[str] = ["list"]
+    sort_by = params.get("sort_by")
+    if isinstance(sort_by, str) and sort_by:
+        args.extend(["--by", sort_by])
+    extra_args = params.get("extra_args")
+    if isinstance(extra_args, list):
+        args.extend(str(item) for item in extra_args if isinstance(item, str))
+    return _run_tmuxctl_capture(args)
+
+
 @click.group(
     name="sessions",
     context_settings={"help_option_names": ["-h", "--help"]},
@@ -149,6 +230,7 @@ def sessions_list(ctx: click.Context, sort_by: Optional[str]) -> None:
     # `ctx.args` holds any extras we ignored (e.g. `--json` once
     # tmuxctl supports it). Forward verbatim, position preserved.
     args.extend(ctx.args)
-    exit_code = _run_tmuxctl(args)
-    if exit_code != 0:
-        ctx.exit(exit_code)
+    envelope = _try_daemon_sessions_list(sort_by=sort_by, extra_args=ctx.args)
+    if envelope is None:
+        envelope = _run_tmuxctl_capture(args)
+    _emit_envelope(ctx, envelope)

{pocketshell-0.3.11 → pocketshell-0.3.13}/tests/test_daemon.py

@@ -728,6 +728,72 @@ def test_cache_invalidate_method_drops_only_that_method() -> None:
     assert cache.invalidate_method("repos.list_local") == 0
 
 
+def _dispatch_in_memory(daemon: daemon_mod.Daemon, method: str, params: dict) -> dict:
+    """Send one request through ``Daemon._handle_one`` using a socketpair."""
+    client, server = socket.socketpair()
+    try:
+        daemon_mod.send_json(
+            client,
+            {"jsonrpc": "2.0", "id": 1, "method": method, "params": params},
+        )
+        daemon._handle_one(server)
+        response = daemon_mod.recv_json(client)
+        assert isinstance(response, dict)
+        return response
+    finally:
+        client.close()
+        server.close()
+
+
+def test_jobs_mutation_invalidates_jobs_list_cache(tmp_path: Path) -> None:
+    """Successful job mutations evict the cached ``jobs.list`` envelope."""
+    calls = {"list": 0}
+
+    def list_handler(_params: dict) -> dict:
+        calls["list"] += 1
+        return {"stdout": f"list-{calls['list']}\n", "stderr": "", "returncode": 0}
+
+    def add_handler(_params: dict) -> dict:
+        return {"stdout": "created\n", "stderr": "", "returncode": 0}
+
+    daemon = daemon_mod.Daemon(
+        socket_path=tmp_path / "daemon.sock",
+        methods={"jobs.list": list_handler, "jobs.add": add_handler},
+    )
+
+    first = _dispatch_in_memory(daemon, "jobs.list", {})
+    assert first["result"]["stdout"] == "list-1\n"
+    assert first["cached"] is False
+
+    cached = _dispatch_in_memory(daemon, "jobs.list", {})
+    assert cached["result"]["stdout"] == "list-1\n"
+    assert cached["cached"] is True
+    assert calls["list"] == 1
+
+    mutation = _dispatch_in_memory(daemon, "jobs.add", {"session_name": "work"})
+    assert mutation["result"]["returncode"] == 0
+
+    after = _dispatch_in_memory(daemon, "jobs.list", {})
+    assert after["result"]["stdout"] == "list-2\n"
+    assert after["cached"] is False
+    assert calls["list"] == 2
+
+
+def test_daemon_registry_includes_sessions_and_jobs_methods() -> None:
+    assert "sessions.list" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.list" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.show" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.trigger" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.add" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.edit" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.remove" in daemon_mod.DEFAULT_METHODS
+    assert "jobs.status" in daemon_mod.DEFAULT_METHODS
+    assert daemon_mod.METHOD_CACHE_INVALIDATIONS["jobs.add"] == ("jobs.list",)
+    assert daemon_mod.METHOD_CACHE_INVALIDATIONS["jobs.edit"] == ("jobs.list",)
+    assert daemon_mod.METHOD_CACHE_INVALIDATIONS["jobs.remove"] == ("jobs.list",)
+    assert daemon_mod.METHOD_CACHE_INVALIDATIONS["jobs.trigger"] == ("jobs.list",)
+
+
 def test_failed_usage_fetch_is_not_cached(
     sandbox_socket: Path,
     tmp_path: Path,

{pocketshell-0.3.11 → pocketshell-0.3.13}/tests/test_jobs.py

@@ -130,6 +130,39 @@ def test_jobs_list_forwards_to_tmuxctl_and_proxies_stdout() -> None:
     assert invoked == ["/fake/tmuxctl", "jobs", "list"]
 
 
+def test_jobs_list_uses_daemon_when_available() -> None:
+    payload = _fake_jobs_table()
+    runner = CliRunner()
+    with patch(
+        "pocketshell.jobs._try_daemon_jobs_call",
+        return_value={"stdout": payload, "stderr": "", "returncode": 0},
+    ) as daemon_call, patch("pocketshell.jobs.subprocess.run") as run:
+        result = runner.invoke(jobs_group, ["list", "--session", "work"])
+    assert result.exit_code == 0, result.output
+    assert result.output == payload
+    daemon_call.assert_called_once_with(
+        "jobs.list",
+        {"extra_args": [], "session": "work"},
+    )
+    run.assert_not_called()
+
+
+def test_jobs_list_falls_back_when_daemon_misses() -> None:
+    payload = _fake_jobs_table()
+    runner = CliRunner()
+    with patch("pocketshell.jobs._try_daemon_jobs_call", return_value=None), patch(
+        "pocketshell.jobs._resolve_tmuxctl_binary", return_value="/fake/tmuxctl"
+    ), patch(
+        "pocketshell.jobs.subprocess.run",
+        return_value=_fake_completed(stdout=payload),
+    ) as run:
+        result = runner.invoke(jobs_group, ["list"])
+    assert result.exit_code == 0, result.output
+    assert result.output == payload
+    invoked: Sequence[str] = run.call_args.args[0]
+    assert invoked == ["/fake/tmuxctl", "jobs", "list"]
+
+
 def test_jobs_list_forwards_unknown_options_verbatim() -> None:
     """The wrapper does NOT enumerate every flag `tmuxctl jobs list`
     grows. The brief calls out a future `--json` flag in particular —
@@ -196,6 +229,31 @@ def test_jobs_trigger_forwards_id() -> None:
     assert invoked == ["/fake/tmuxctl", "jobs", "trigger", "7"]
 
 
+def test_jobs_mutation_uses_daemon_when_available() -> None:
+    runner = CliRunner()
+    with patch(
+        "pocketshell.jobs._try_daemon_jobs_call",
+        return_value={"stdout": "Created job 7\n", "stderr": "", "returncode": 0},
+    ) as daemon_call, patch("pocketshell.jobs.subprocess.run") as run:
+        result = runner.invoke(
+            jobs_group,
+            ["add", "work", "--every", "15m", "--message", "poke claude"],
+        )
+    assert result.exit_code == 0, result.output
+    assert result.output == "Created job 7\n"
+    daemon_call.assert_called_once_with(
+        "jobs.add",
+        {
+            "session_name": "work",
+            "every": "15m",
+            "message": "poke claude",
+            "start_now": False,
+            "extra_args": [],
+        },
+    )
+    run.assert_not_called()
+
+
 def test_jobs_trigger_proxies_unknown_subcommand_failure() -> None:
     """If `tmuxctl` has not yet implemented `jobs trigger`, the wrapper
     must surface the failure unchanged rather than silently swallowing
@@ -600,6 +658,19 @@ def test_jobs_daemon_status_running_reports_zero() -> None:
     assert invoked[2].startswith("(^|/)") or invoked[2].startswith("(")
 
 
+def test_jobs_daemon_status_uses_daemon_when_available() -> None:
+    runner = CliRunner()
+    with patch(
+        "pocketshell.jobs._try_daemon_jobs_call",
+        return_value={"stdout": "running\n", "stderr": "", "returncode": 0},
+    ) as daemon_call, patch("pocketshell.jobs.subprocess.run") as run:
+        result = runner.invoke(jobs_group, ["daemon", "status"])
+    assert result.exit_code == 0, result.output
+    assert result.output == "running\n"
+    daemon_call.assert_called_once_with("jobs.status", {})
+    run.assert_not_called()
+
+
 def test_jobs_daemon_status_not_running_reports_three() -> None:
     runner = CliRunner()
     with patch("pocketshell.jobs.shutil.which", return_value="/fake/pgrep"), patch(

{pocketshell-0.3.11 → pocketshell-0.3.13}/tests/test_sessions.py

@@ -106,6 +106,39 @@ def test_sessions_list_forwards_to_tmuxctl_and_proxies_stdout() -> None:
     assert invoked == ["/fake/tmuxctl", "list"]
 
 
+def test_sessions_list_uses_daemon_when_available() -> None:
+    payload = _fake_sessions_table()
+    runner = CliRunner()
+    with patch(
+        "pocketshell.sessions._try_daemon_sessions_list",
+        return_value={"stdout": payload, "stderr": "", "returncode": 0},
+    ) as daemon_call, patch("pocketshell.sessions.subprocess.run") as run:
+        result = runner.invoke(sessions_group, ["list", "--by", "activity"])
+    assert result.exit_code == 0, result.output
+    assert result.output == payload
+    daemon_call.assert_called_once_with(sort_by="activity", extra_args=[])
+    run.assert_not_called()
+
+
+def test_sessions_list_falls_back_when_daemon_misses() -> None:
+    payload = _fake_sessions_table()
+    runner = CliRunner()
+    with patch(
+        "pocketshell.sessions._try_daemon_sessions_list",
+        return_value=None,
+    ), patch(
+        "pocketshell.sessions._resolve_tmuxctl_binary", return_value="/fake/tmuxctl"
+    ), patch(
+        "pocketshell.sessions.subprocess.run",
+        return_value=_fake_completed(stdout=payload),
+    ) as run:
+        result = runner.invoke(sessions_group, ["list"])
+    assert result.exit_code == 0, result.output
+    assert result.output == payload
+    invoked: Sequence[str] = run.call_args.args[0]
+    assert invoked == ["/fake/tmuxctl", "list"]
+
+
 def test_sessions_list_forwards_by_activity() -> None:
     runner = CliRunner()
     with patch(

{pocketshell-0.3.11 → pocketshell-0.3.13}/uv.lock

@@ -143,7 +143,7 @@ wheels = [
 
 [[package]]
 name = "pocketshell"
-version = "0.3.11"
+version = "0.3.13"
 source = { editable = "." }
 dependencies = [
     { name = "click" },