taskops-cli 0.2.0__py3-none-any.whl

taskops/transports/cli/commands/ui.py

@@ -0,0 +1,72 @@
+"""`taskops ui` — the live board, and its API, on one port."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from ....transports.http import Policy, bound_port, build_server
+from ....usecases import locate
+from ._shared import add_target, repo_of
+
+__all__ = ["register"]
+
+DEFAULT_PORT = 2140
+
+_HELP = "serve the live web interface (board, activity, reports)"
+
+
+def register(sub: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
+    """Two parsers, one `run`.
+
+    `studio` was the name until the web interface stopped being one screen, and a command in
+    somebody's shell history — or in a script, or a README they already wrote — must not start
+    failing because we renamed it. The alias registers with no `help`, so it never appears in
+    `taskops --help`: it is a bridge for existing muscle memory, not a second documented way in.
+    """
+    _flags(sub.add_parser("ui", help=_HELP))
+    _flags(sub.add_parser("studio")).set_defaults(deprecated_name=True)
+
+
+def _flags(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    """Every flag on both parsers, from one place — an alias that drifted on `--readonly`
+    would be worse than no alias at all."""
+    add_target(parser)
+    parser.add_argument("--host", default="127.0.0.1",
+                        help="bind address (default: loopback only)")
+    parser.add_argument("--port", type=int, default=DEFAULT_PORT)
+    parser.add_argument("--token", default=os.environ.get("TASKOPS_API_TOKEN", ""),
+                        help="require `Authorization: Bearer <token>` ($TASKOPS_API_TOKEN)")
+    parser.add_argument("--readonly", action="store_true",
+                        help="refuse every write — for a board on a shared screen")
+    parser.add_argument("--rate-limit", type=int, default=0, dest="rate_limit",
+                        help="requests per minute, 0 for none")
+    parser.set_defaults(run=run, deprecated_name=False)
+    return parser
+
+
+def run(args: argparse.Namespace) -> str:
+    """Blocks until interrupted.
+
+    The banner goes to STDERR so it stays visible when stdout is redirected, and it is the only
+    thing this command prints — the request log is silenced in the handler, or the URL a person
+    needs would scroll away under the board's own polling. The deprecation line joins it there
+    for the same reason: it is a note to a human, never part of the output.
+    """
+    if getattr(args, "deprecated_name", False):
+        print("taskops studio is now taskops ui", file=sys.stderr)
+    root = locate(repo_of(args))
+    policy = Policy(token=args.token, readonly=bool(args.readonly),
+                    rate_limit=int(args.rate_limit))
+    server = build_server(str(args.host), int(args.port), root, policy)
+    print(f"taskops ui → http://{args.host}:{bound_port(server)}/  ({root})"
+          + ("  [token required]" if args.token else "")
+          + ("  [read-only]" if args.readonly else ""), file=sys.stderr)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nstopped", file=sys.stderr)
+    finally:
+        server.server_close()
+    return ""

taskops/transports/cli/commands/update.py

@@ -0,0 +1,25 @@
+"""A transition, a comment, a mention — the write path, reached from `taskops tasks`.
+
+`taskops update` was the agent's spelling and left with the rest of the agent protocol; the
+FUNCTION could not leave, because `tasks done` and `tasks release` are this call with the
+status already chosen. A second door onto `done` that skipped this is exactly what the guard
+in `usecases.update` exists to prevent.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from ....render import render_update
+from ....usecases import update as apply
+from ._shared import repo_of
+
+__all__ = ["run"]
+
+
+def run(args: argparse.Namespace) -> str:
+    mentions = tuple(p.strip() for p in str(args.mentions).split(",") if p.strip())
+    return render_update(apply(repo_of(args), str(args.task), actor=args.actor,
+                               status=args.status, comment=args.comment,
+                               mentions=mentions, blocked_on=args.blocked_on,
+                               no_code=bool(args.no_code)))

taskops/transports/cli/main.py

@@ -0,0 +1,85 @@
+"""The CLI: parse, dispatch, and translate a failure into an exit code.
+
+The commands hold no argparse beyond their own flags and no decision beyond which renderer
+to use. That is what lets the same behaviour be reached from MCP without a second
+implementation, and it keeps this file about the terminal.
+
+Exit codes: 0 fine, 1 an engine failure, 2 bad usage. Nothing here means anything else — the
+one command that used an exit code as an ANSWER was `guard`, and it left with the rest of the
+wiring for `transports/hooks`, where the caller is a hook rather than a person.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Sequence
+
+from ..._errors import TaskopsError
+from ..._version import __version__
+from .commands import init, pushpull, recover, remote, report, run_, serve, sync, tasks, ui
+
+__all__ = ["main", "build_parser"]
+
+_COMMANDS = (init, ui, serve, tasks, run_, report, recover, sync, remote, pushpull)
+"""Every command there is. Eleven, and `--help` lists all eleven.
+
+`serve` sits next to `ui` because it is the same transport with a different audience: `ui`
+serves the repository you are standing in, `serve` serves a directory of them over the network,
+each behind its own token.
+
+`remote`, `push` and `pull` are the developer's, which is why they are here and NOT on the
+MCP surface: an agent works a board, it does not decide when this machine talks to a server.
+They sit beside `sync` rather than replacing it — a team with no server converges through git
+exactly as before, and that path is not deprecated by this one.
+
+There used to be thirteen more, registered and hidden — the agent protocol (`next`, `update`,
+`ask`, `plan`, `dispatch`, `log`) and the wiring (`guard`, `hook`, `ingest`, `brief`, `inbox`,
+`track`, `checkout`). Hiding them made the help page honest and left the door open: git and
+Claude Code still came in through the developer's binary. The agent's door is `taskops.mcp`
+and the wiring's is `python -m taskops.transports.hooks`, so these are gone rather than
+hidden, and the machinery that hid them went with them.
+
+`run` is listed even though it is experimental and costs money, because the alternative was
+worse: it lived as `dispatch --spawn`, a flag on a hidden command, so the one thing here that
+spends money was the hardest thing to find and the easiest to hit by accident."""
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Every command registers its own flags. Adding one is a new module in `commands/`,
+    never a branch here."""
+    parser = argparse.ArgumentParser(
+        prog="taskops",
+        description="The shared task list for Claude Code agents: persistent tasks, "
+                    "atomic claims, commits bound to the work that motivated them.")
+    parser.add_argument("--version", action="version", version=__version__)
+    sub = parser.add_subparsers(dest="command", required=True, metavar="<command>")
+    for module in _COMMANDS:
+        module.register(sub)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run one command. A typed failure prints ONE line naming what to do.
+
+    A traceback is for the person who can fix the code; the reader here is trying to use the
+    tool, or is a hook that will show the line to an agent.
+    """
+    args = build_parser().parse_args(argv)
+    try:
+        output = args.run(args)
+    except (TaskopsError, OSError) as err:
+        # OSError too: a path that does not exist or cannot be read is an ordinary mistake,
+        # and the person who made it wants one line, not a traceback through pathlib.
+        print(f"taskops: {err}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("interrupted", file=sys.stderr)
+        return 130
+    if output:
+        print(output)
+    return 0
+
+
+if __name__ == "__main__":       # `python -m taskops.transports.cli.main`
+    raise SystemExit(main())

taskops/transports/hooks/__init__.py

@@ -0,0 +1,15 @@
+"""The wiring transport: the door git and Claude Code come through.
+
+Three audiences, three doors. `cli/` is the developer's, `mcp/` is the agent's, and this one
+belongs to the two callers that are neither — git, which runs shell scripts, and Claude Code,
+which runs `{"type": "command"}` entries. Both EXECUTE something, so something executable has
+to exist; what this module changes is that it stopped being the developer's `taskops`.
+
+Nobody types `python -m taskops.transports.hooks`. It is written into `.git/hooks/*` by
+`usecases.hooks` and into `plugin/hooks/hooks.json`, and read by nothing else.
+
+It is a transport like the other two and obeys the same fence: thin, no `storage`, no
+`engine` — `test_transports_never_reach_past_the_use_cases` is what enforces it.
+"""
+
+from __future__ import annotations

taskops/transports/hooks/__main__.py

@@ -0,0 +1,63 @@
+"""`python -m taskops.transports.hooks <event>` — the executable the wiring names.
+
+Seven flat subcommands, one per thing that can fire:
+
+```
+pre-tool-use  post-tool-use  session-start  stop     Claude Code, JSON on stdin
+commit                                               Claude Code, exit 2 = DENY
+ingest commit|branch          sync                   git: post-commit, post-checkout, post-merge
+```
+
+Flat, and named after the EVENT rather than the internal verb, because the reader of these
+names is somebody staring at a `hooks.json` entry or a line in `.git/hooks/post-commit`.
+
+Exit codes are the contract and they differ per subcommand, which is why `main` returns
+whatever `run` returned instead of flattening it: `commit` answers 2 to deny, the Claude Code
+events answer 0 always with the decision inside the JSON, and everything fails OPEN.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Sequence
+
+from ..._errors import TaskopsError
+from . import claude, commit, record
+
+__all__ = ["main", "build_parser"]
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m taskops.transports.hooks",
+        description="taskops wiring: the commands git and Claude Code run. Not for typing — "
+                    "`taskops init` writes them into .git/hooks, and the plugin ships the rest.")
+    sub = parser.add_subparsers(dest="event", required=True, metavar="<event>")
+    for module in (claude, commit, record):
+        module.register(sub)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run one hook. A typed failure is ONE line on stderr, never a traceback.
+
+    Code 1 for a failure the way the CLI does it, because git's line ends in `|| true` and
+    Claude Code reads any non-zero-but-not-2 as a non-blocking error. The one code that means
+    something is 2, and only `commit` returns it.
+    """
+    args = build_parser().parse_args(argv)
+    try:
+        output = args.run(args)
+    except (TaskopsError, OSError) as err:
+        print(f"taskops: {err}", file=sys.stderr)
+        return 1
+    if isinstance(output, int):
+        return output
+    if output:
+        print(output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

taskops/transports/hooks/_args.py

@@ -0,0 +1,28 @@
+"""What every wiring subcommand's parser repeats.
+
+`--repo` defaults to the cwd because the callers are hooks: git runs them from inside the
+repository, and Claude Code runs them from the project directory, so requiring the path would
+make every hook line longer for no information.
+
+A copy of `cli/commands/_shared` rather than an import of it: a transport that imported
+another transport would make the developer's CLI a dependency of git's wiring, which is the
+coupling this whole module exists to remove. It is four lines, and they do not drift because
+`test_hook_wiring` runs the real installed hook.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+__all__ = ["add_target", "repo_of"]
+
+
+def add_target(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--repo", default=".",
+                        help="path in the repository (default: the current directory)")
+    parser.add_argument("--actor", default="", help="who is calling")
+
+
+def repo_of(args: argparse.Namespace) -> Path:
+    return Path(str(args.repo))

taskops/transports/hooks/claude.py

@@ -0,0 +1,78 @@
+"""`pre-tool-use · post-tool-use · session-start · stop` — the Claude Code hook protocol.
+
+The whole integration in four subcommands. A hook receives a JSON object on stdin and may
+answer with one on stdout; this is the wire, and `events` is what each event means. The names
+are the EVENTS themselves, because that is what the person wiring `hooks.json` is holding —
+not a verb taskops happens to call it internally.
+
+```
+PreToolUse    permissionDecision: "deny"     refuse the tool call, with a reason
+              updatedInput: {...}            REWRITE it — this is how the Task trailer
+                                             gets into the agent's own `git commit`
+SessionStart  additionalContext: "..."       inject what the session holds and its messages
+PostToolUse   additionalContext: "..."       deliver a message another agent just wrote
+```
+
+Everything here FAILS OPEN with an empty object. A hook that raised would block the tool call
+it was inspecting, and blocking a developer's commit because taskops had a bad day is how a
+coordination tool gets uninstalled.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any, Callable, cast
+
+from ..._errors import TaskopsError
+from . import events
+
+__all__ = ["register", "HANDLERS"]
+
+HANDLERS: dict[str, Callable[[dict[str, Any]], dict[str, Any]]] = {
+    "pre-tool-use": events.pre_tool_use,
+    "post-tool-use": events.post_tool_use,
+    "session-start": events.session_start,
+    "stop": events.stop,
+}
+
+
+def register(sub: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
+    """One parser per event, flat. A `hook <event>` group would put a word in every line of
+    `hooks.json` that carries no information — the module name already said "hook"."""
+    for name in sorted(HANDLERS):
+        parser = sub.add_parser(name, help=f"the Claude Code {name} hook (stdin JSON)")
+        parser.set_defaults(run=run, event=name)
+
+
+def run(args: argparse.Namespace) -> int:
+    """Read the event, print the response, exit 0 ALWAYS.
+
+    Zero even for a denial: the decision travels in the JSON, and a non-zero exit is ALSO read
+    as a denial — so returning both would refuse the call twice, once without the reason
+    attached, and the agent would see the version that tells it nothing.
+    """
+    handler = HANDLERS[str(args.event)]
+    try:
+        response = handler(_stdin())
+    except (TaskopsError, OSError, ValueError):
+        response = {}
+    if response:
+        print(json.dumps(response))
+    return 0
+
+
+def _stdin() -> dict[str, Any]:
+    """The event payload, or {} for anything unreadable.
+
+    A hook run by hand has no stdin at all, so the tty check comes first — without it, running
+    `stop` in a terminal would block forever waiting for input nobody is going to send.
+    """
+    if sys.stdin.isatty():
+        return {}
+    try:
+        parsed: object = json.loads(sys.stdin.read() or "{}")
+    except (json.JSONDecodeError, OSError):
+        return {}
+    return cast("dict[str, Any]", parsed) if isinstance(parsed, dict) else {}

taskops/transports/hooks/commit.py

@@ -0,0 +1,61 @@
+"""`commit` — may this commit proceed? The verdict, as an exit code.
+
+Was `taskops guard commit`. The name is now the thing being decided, because the caller is a
+hook line asking about a commit, not a person reaching for a noun.
+
+Claude Code's hook protocol is the reason this subcommand returns an int instead of text:
+
+```
+exit 0  -> allow. stdout is shown to the user, not to the model.
+exit 2  -> DENY. stderr goes to the MODEL, which is how the agent learns the reason.
+other   -> a non-blocking error; the tool call proceeds.
+```
+
+So a refusal must be written to STDERR with code 2, and anything else — including a crash in
+taskops itself — must let the commit through. That last part is deliberate: a coordination
+tool that blocks commits because its database was locked has broken the thing it exists to
+support, and there is a `post-commit` hook that will record the commit anyway.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from ..._errors import TaskopsError
+from ...render import render_verdict
+from ...usecases import check_commit
+from ._args import add_target, repo_of
+
+__all__ = ["register", "DENY", "ALLOW"]
+
+DENY = 2
+ALLOW = 0
+
+
+def register(sub: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
+    parser = sub.add_parser("commit", help="decide whether a commit may proceed")
+    add_target(parser)
+    parser.add_argument("--message", default="", help="the commit message being written")
+    parser.set_defaults(run=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    """The verdict, as an exit code. Prints the amended message on stdout when allowed.
+
+    Every unexpected failure ALLOWS. Fail-open is the right default for a guard in the commit
+    path: the cost of wrongly allowing one commit is a missing association that `post-commit`
+    will usually add anyway, and the cost of wrongly blocking is a developer who cannot commit
+    and a tool they will uninstall.
+    """
+    try:
+        verdict = check_commit(repo_of(args), str(args.message), actor=str(args.actor))
+    except (TaskopsError, OSError) as err:
+        print(f"taskops guard could not run ({err}) — allowing the commit", file=sys.stderr)
+        return ALLOW
+    if not verdict.allowed:
+        print(render_verdict(verdict), file=sys.stderr)
+        return DENY
+    if verdict.message and verdict.message != args.message:
+        print(verdict.message)
+    return ALLOW

taskops/transports/hooks/events.py

@@ -0,0 +1,107 @@
+"""One Claude Code hook event -> the JSON object the harness reads back.
+
+Split from `claude` the same way `mcp/dispatch` is split from `mcp/protocol`: that module is
+the wire (read stdin, route, write stdout), and this one is what each event MEANS. Every
+handler here returns `{}` when there is nothing to say, and that silence is load-bearing —
+these fire on every tool call, so a handler that always spoke would inject noise into a
+session hundreds of times.
+
+This is also where `brief`/`inbox`/`track`/`checkout` ended up. They used to be four CLI
+commands a hook line typed one at a time; the events call the same use cases directly, so the
+commands were a spelling of this file that a person could reach and nobody should.
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from ...render import render_brief, render_inbox
+from ...usecases import brief, check_command, checkout, inbox, track
+
+__all__ = ["pre_tool_use", "post_tool_use", "session_start", "stop"]
+
+
+def pre_tool_use(payload: dict[str, Any]) -> dict[str, Any]:
+    """Guard a `git commit`; pass everything else straight through.
+
+    The matcher can only filter on the TOOL name, so this runs on every Bash call — which is
+    why the not-a-commit path must be free, and why recognising a commit belongs to the use
+    case rather than being reimplemented here.
+    """
+    command = str(input_of(payload).get("command", ""))
+    verdict = check_command(cwd(payload), command)
+    if verdict is None:
+        return {}
+    if not verdict.allowed:
+        return _deny(verdict.reason)
+    if verdict.command and verdict.command != command:
+        return _rewrite(verdict.command)
+    return {}
+
+
+def _deny(reason: str) -> dict[str, Any]:
+    return {"hookSpecificOutput": {"hookEventName": "PreToolUse",
+                                   "permissionDecision": "deny",
+                                   "permissionDecisionReason": f"taskops: {reason}"}}
+
+
+def _rewrite(command: str) -> dict[str, Any]:
+    """Allow, with the trailer injected. The reason is given, so the edit is never silent —
+    an agent whose command was changed underneath it deserves to be told which and why."""
+    return {"hookSpecificOutput": {
+        "hookEventName": "PreToolUse", "permissionDecision": "allow",
+        "permissionDecisionReason": "taskops: added the Task trailer to bind this commit",
+        "updatedInput": {"command": command}}}
+
+
+def session_start(payload: dict[str, Any]) -> dict[str, Any]:
+    """Inject what this session holds and who messaged it."""
+    said = render_brief(brief(cwd(payload), session=session_of(payload)))
+    return _context("SessionStart", said)
+
+
+def post_tool_use(payload: dict[str, Any]) -> dict[str, Any]:
+    """Two jobs on the cheapest hook: report activity, and deliver new messages.
+
+    This is what makes agent-to-agent messaging feel immediate — a message written by another
+    agent reaches this one on its very next tool call. Both halves are one indexed query, and
+    both are usually zero rows, because anything expensive here taxes every tool call an agent
+    ever makes.
+    """
+    where = cwd(payload)
+    track(where, summary=_summary(payload), session=session_of(payload))
+    return _context("PostToolUse", render_inbox(inbox(where)))
+
+
+def _summary(payload: dict[str, Any]) -> str:
+    """What the live board shows as "doing": the tool, and the file or command it touched."""
+    tool = str(payload.get("tool_name", "?"))
+    target = input_of(payload).get("file_path") or input_of(payload).get("command") or ""
+    return f"{tool} {str(target)[:60]}".strip()
+
+
+def stop(payload: dict[str, Any]) -> dict[str, Any]:
+    """The auto-standup: post the session's own account to every task it holds."""
+    checkout(cwd(payload), summary="Session ended.", session=session_of(payload))
+    return {}
+
+
+def _context(event: str, text: str) -> dict[str, Any]:
+    """The inject-context shape, or {} for nothing to inject."""
+    if not text:
+        return {}
+    return {"hookSpecificOutput": {"hookEventName": event, "additionalContext": text}}
+
+
+def input_of(payload: dict[str, Any]) -> dict[str, Any]:
+    found: object = payload.get("tool_input")
+    return cast("dict[str, Any]", found) if isinstance(found, dict) else {}
+
+
+def cwd(payload: dict[str, Any]) -> str:
+    """Where the session is. Defaults to "." so a hand-run hook still works."""
+    return str(payload.get("cwd") or ".")
+
+
+def session_of(payload: dict[str, Any]) -> str:
+    return str(payload.get("session_id") or "")

taskops/transports/hooks/record.py

@@ -0,0 +1,55 @@
+"""`ingest commit|branch` and `sync` — what git tells taskops after the fact.
+
+The other half of git-binding. `commit` runs BEFORE a commit and can deny; `ingest` runs after
+one and only records — which is why it also catches every commit the guard never saw: a
+human's terminal commit, a `--no-verify`, a rebase landing on a task branch.
+
+`sync` is here rather than left on the developer's CLI for one reason: `post-merge` is a git
+hook line, and a git hook line may not enter through the door a person types. `taskops sync`
+still exists for the person, reaching the same use case; this is the same call with its
+report thrown away, because git redirects the hook's output to /dev/null anyway.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from ...usecases import ingest_branch, ingest_commit
+from ...usecases import sync as reconcile
+from ._args import add_target, repo_of
+
+__all__ = ["register"]
+
+
+def register(sub: "argparse._SubParsersAction[argparse.ArgumentParser]") -> None:
+    parser = sub.add_parser("ingest", help="record a commit or a branch against its task")
+    add_target(parser)
+    parser.add_argument("what", choices=("commit", "branch"))
+    parser.add_argument("ref", nargs="?", default="", help="a sha, or a branch name")
+    parser.set_defaults(run=run)
+
+    merged = sub.add_parser("sync", help="import what a merge just brought in (post-merge)")
+    add_target(merged)
+    merged.set_defaults(run=run_sync)
+
+
+def run(args: argparse.Namespace) -> str:
+    """Silent when there was nothing to bind.
+
+    A commit on a non-task branch is completely normal — this hook fires on every commit in
+    the repository, including the ones taskops has no opinion about — so saying so would put a
+    line of noise in front of a developer on every unrelated commit.
+    """
+    where = repo_of(args)
+    if args.what == "branch":
+        event = ingest_branch(where, str(args.ref), actor=str(args.actor))
+        return f"taskops: {event['task']} on {event['body'].get('branch')}" if event else ""
+    event = ingest_commit(where, str(args.ref) or "HEAD", actor=str(args.actor))
+    return f"taskops: recorded {str(event['body'].get('sha'))[:12]} on {event['task']}" \
+        if event else ""
+
+
+def run_sync(args: argparse.Namespace) -> str:
+    """Silent by design: the report belongs to `taskops sync`, which a person reads."""
+    reconcile(repo_of(args))
+    return ""

taskops/transports/http/__init__.py

@@ -0,0 +1,21 @@
+"""The HTTP transport: the studio's UI and its JSON API on one port.
+
+Layered like the MCP one and for the same reasons — `_wire` is the request/reply shape, `policy`
+is who may do what, `api` is the endpoints, `live` is the SSE feed, `static` serves the built
+bundle, `router` maps a path to one of them, and `server` is the only file that knows about HTTP.
+
+This is the one place the codebase is allowed to be async-adjacent, and it is not: it uses threads
+(`ThreadingHTTPServer`), which is what lets a live browser park in a generator while the sync
+engine underneath stays sync. See `live` for why the feed is SSE rather than a WebSocket.
+
+`projects` is the one piece that is not part of a single board: it mounts many of them under
+`/<project>/`, which is what `taskops serve` opens and `taskops ui` never uses.
+"""
+
+from __future__ import annotations
+
+from .policy import Policy
+from .projects import mount
+from .server import bound_port, build_server, serve_route
+
+__all__ = ["Policy", "build_server", "serve_route", "bound_port", "mount"]