taskgate 0.1.0__py3-none-any.whl

taskgate/model.py

@@ -0,0 +1,158 @@
+"""Task data model: statuses, transitions and registry validation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .config import Config
+
+STATUSES = (
+    "draft",
+    "planned",
+    "in_progress",
+    "in_review",
+    "blocked",
+    "done",
+    "cancelled",
+)
+TERMINAL = frozenset({"done", "cancelled"})
+# Started but not finished: such a task is the queue head and nothing may be inserted before it.
+IN_FLIGHT = frozenset({"in_progress", "in_review", "blocked"})
+
+TRANSITIONS: dict[str, frozenset[str]] = {
+    "draft": frozenset({"planned", "cancelled"}),
+    "planned": frozenset({"in_progress", "cancelled"}),
+    "in_progress": frozenset({"in_review", "blocked", "cancelled"}),
+    "blocked": frozenset({"in_progress", "cancelled"}),
+    "in_review": frozenset({"done", "in_progress", "cancelled"}),
+    "done": frozenset(),
+    "cancelled": frozenset(),
+}
+
+REQUIRED_FIELDS = ("id", "title", "status", "verification_cmd")
+OPTIONAL_FIELDS = (
+    "phase",
+    "owner",
+    "depends_on",
+    "spec_source",
+    "verification_result",
+    "review_result",
+    "blocked_reason",
+    "notes",
+    "links",
+    "created",
+    "updated",
+    "started",
+    "finished",
+)
+
+#: Statuses a new task may start in; work starts through ``claim``.
+ADD_STATUSES = ("draft", "planned")
+
+
+class ValidationError(ValueError):
+    """Raised when a task or registry violates the schema or flow rules."""
+
+
+def can_transition(current: str, new: str) -> bool:
+    """Return True when the status change is allowed."""
+    return new in TRANSITIONS.get(current, frozenset())
+
+
+def is_green(result: Any) -> bool:
+    """True when a verification or review result is a dict with ``ok: true``."""
+    return isinstance(result, dict) and result.get("ok") is True
+
+
+def is_review(result: Any, reviewer: str) -> bool:
+    """True when a result is green and carries the configured reviewer identity."""
+    return is_green(result) and result.get("by") == reviewer
+
+
+def phase_of(task: dict[str, Any]) -> int:
+    """The task's phase; tasks without one are in phase 0."""
+    phase = task.get("phase", 0)
+    return phase if isinstance(phase, int) and not isinstance(phase, bool) else 0
+
+
+def _validate_task(task: dict[str, Any], config: Config) -> list[str]:
+    errors: list[str] = []
+    tid = task.get("id", "<missing>")
+    match = config.id_regex.fullmatch(tid) if isinstance(tid, str) else None
+    if match is None:
+        errors.append(f"{tid}: id must match {config.id_pattern}")
+        return errors
+    for name in REQUIRED_FIELDS:
+        value = task.get(name)
+        if not isinstance(value, str) or not value:
+            errors.append(f"{tid}: field {name!r} is required (non-empty string)")
+    phase = task.get("phase", 0)
+    if not isinstance(phase, int) or isinstance(phase, bool) or phase < 0:
+        errors.append(f"{tid}: phase must be an integer >= 0")
+    elif "phase" in match.groupdict() and match.group("phase") is not None and phase != int(match.group("phase")):
+        errors.append(f"{tid}: phase {phase} does not match the id")
+    status = task.get("status")
+    if status not in STATUSES:
+        errors.append(f"{tid}: unknown status {status!r}")
+    owner = task.get("owner")
+    if owner is not None and config.owners is not None and owner not in config.owners:
+        errors.append(f"{tid}: unknown owner {owner!r}")
+    deps = task.get("depends_on", [])
+    if not isinstance(deps, list) or not all(isinstance(d, str) for d in deps):
+        errors.append(f"{tid}: depends_on must be a list of task ids")
+    if task.get("blocked_reason") is not None and status != "blocked":
+        errors.append(f"{tid}: blocked_reason set but status is {status!r}")
+    if status == "blocked" and not task.get("blocked_reason"):
+        errors.append(f"{tid}: blocked requires non-empty blocked_reason")
+    if status in ("in_review", "done") and not is_green(task.get("verification_result")):
+        errors.append(f"{tid}: status {status!r} requires a green verification_result")
+    if status == "done" and config.require_review and not is_review(task.get("review_result"), config.reviewer):
+        errors.append(
+            f"{tid}: status 'done' requires a green review_result "
+            f"({{'ok': true, 'by': '{config.reviewer}', ...}})"
+        )
+    if not isinstance(task.get("notes", []), list):
+        errors.append(f"{tid}: notes must be a list")
+    if not isinstance(task.get("links", []), list):
+        errors.append(f"{tid}: links must be a list")
+    return errors
+
+
+def validate(data: dict[str, Any], config: Config) -> list[str]:
+    """Validate the whole registry JSON. Returns a list of error strings."""
+    if not isinstance(data, dict):
+        return ["registry root must be a JSON object"]
+    tasks = data.get("tasks")
+    if not isinstance(tasks, list):
+        return ["registry must contain a 'tasks' list"]
+    errors: list[str] = []
+    version = data.get("version", 1)
+    if version != 1:
+        errors.append(f"unsupported registry version {version!r}")
+    known: dict[str, dict[str, Any]] = {}
+    phases = [phase_of(t) for t in tasks if isinstance(t, dict)]
+    if phases != sorted(phases):
+        errors.append("tasks are not grouped by ascending phase (reorder with 'move' or run 'taskgate sort')")
+    position = {t["id"]: i for i, t in enumerate(tasks) if isinstance(t, dict) and isinstance(t.get("id"), str)}
+    for task in tasks:
+        if not isinstance(task, dict):
+            errors.append("each task must be a JSON object")
+            continue
+        errors.extend(_validate_task(task, config))
+        tid = task.get("id")
+        if isinstance(tid, str):
+            if tid in known:
+                errors.append(f"{tid}: duplicate task id")
+            known[tid] = task
+    allowed = set(REQUIRED_FIELDS) | set(OPTIONAL_FIELDS)
+    for task in tasks:
+        if not isinstance(task, dict):
+            continue
+        tid = task.get("id", "<missing>")
+        for dep in task.get("depends_on") or []:
+            if dep not in known:
+                errors.append(f"{tid}: depends_on references unknown task {dep!r}")
+            elif position.get(dep, 0) >= position.get(tid, 0):
+                errors.append(f"{tid}: depends_on {dep!r}, which is not placed before it")
+        errors.extend(f"{tid}: unknown field {name!r}" for name in task if name not in allowed)
+    return errors

taskgate/ordering.py

@@ -0,0 +1,119 @@
+"""Execution order of the registry: queue head, current phase and claim gates."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from .config import Config
+from .model import IN_FLIGHT, TERMINAL, phase_of, validate
+
+MOVABLE = frozenset({"draft", "planned"})
+
+
+def _natural(text: str) -> list[tuple[int, int, str]]:
+    """Sort key splitting digit runs, so ``T-2`` sorts before ``T-10``."""
+    return [(0, int(p), "") if p.isdigit() else (1, 0, p) for p in re.split(r"(\d+)", text) if p]
+
+
+def sorted_tasks(tasks: list[Any]) -> list[Any]:
+    """Tasks sorted by phase, then id; the ``sort`` command's order, not the execution order."""
+    def key(task: Any) -> tuple[int, list[tuple[int, int, str]]]:
+        return (phase_of(task), _natural(str(task.get("id", "")))) if isinstance(task, dict) else (0, [])
+
+    return sorted(tasks, key=key)
+
+
+def execution_order(tasks: list[Any]) -> list[dict[str, Any]]:
+    """Tasks in execution order: their position in the registry (``move`` changes it)."""
+    return [task for task in tasks if isinstance(task, dict)]
+
+
+def queue_head(tasks: list[Any]) -> dict[str, Any] | None:
+    """First task in execution order that is not terminal, or None when all are."""
+    for task in execution_order(tasks):
+        if task.get("status") not in TERMINAL:
+            return task
+    return None
+
+
+def current_phase(tasks: list[Any]) -> int:
+    """Phase of the queue head; the highest phase present once everything is terminal."""
+    head = queue_head(tasks)
+    if head is not None:
+        return phase_of(head)
+    return max((phase_of(t) for t in execution_order(tasks)), default=0)
+
+
+def claim_blockers(data: dict[str, Any], task: dict[str, Any], config: Config) -> list[str]:
+    """Reasons ``task`` may not be started now; empty when claiming is allowed.
+
+    Execution is strictly ordered: every task before it must be terminal. For a
+    task in a later phase that is the phase gate: all earlier phases are closed
+    and the whole registry passes ``validate`` (green verification, and review
+    evidence on every ``done`` task when review is required).
+    """
+    reasons = [f"registry invalid: {e}" for e in validate(data, config)]
+    tasks = data.get("tasks", [])
+    for earlier in execution_order(tasks):
+        if earlier.get("id") == task.get("id"):
+            break
+        if earlier.get("status") in TERMINAL:
+            continue
+        if phase_of(earlier) != phase_of(task):
+            reasons.append(
+                f"phase gate: phase {phase_of(earlier)} is not closed "
+                f"({earlier.get('id')} is {earlier.get('status')!r})"
+            )
+        else:
+            reasons.append(f"order: {earlier.get('id')} comes first and is {earlier.get('status')!r}")
+    statuses = {t.get("id"): t.get("status") for t in execution_order(tasks)}
+    for dep in task.get("depends_on") or []:
+        if statuses.get(dep) != "done":
+            reasons.append(f"dependency {dep} is {statuses.get(dep)!r}, not 'done'")
+    return reasons
+
+
+def move_blockers(tasks: list[Any], task_id: str, anchor_id: str, after: bool) -> list[str]:
+    """Reasons ``task_id`` may not be placed before/after ``anchor_id``; empty when the move is allowed.
+
+    Only tasks that have not started can move, and never in front of a task that is
+    in flight or done: execution history stays where it happened.
+    """
+    ordered = execution_order(tasks)
+    by_id = {t.get("id"): t for t in ordered}
+    if task_id not in by_id:
+        return [f"unknown task {task_id}"]
+    if anchor_id not in by_id:
+        return [f"unknown task {anchor_id}"]
+    if task_id == anchor_id:
+        return ["a task cannot be moved relative to itself"]
+    status = by_id[task_id].get("status")
+    if status not in MOVABLE:
+        return [f"{task_id} is {status!r}; only {', '.join(sorted(MOVABLE))} tasks can be moved"]
+    rest = [t for t in ordered if t.get("id") != task_id]
+    index = next(i for i, t in enumerate(rest) if t.get("id") == anchor_id) + (1 if after else 0)
+    return [
+        f"{t.get('id')} is {t.get('status')!r} and already started or finished; "
+        f"{task_id} cannot be placed in front of it"
+        for t in rest[index:]
+        if t.get("status") in IN_FLIGHT or t.get("status") == "done"
+    ]
+
+
+def moved(tasks: list[Any], task_id: str, anchor_id: str, after: bool) -> list[Any]:
+    """The task list with ``task_id`` placed before/after ``anchor_id``; callers check ``move_blockers`` first."""
+    ordered = execution_order(tasks)
+    task = next(t for t in ordered if t.get("id") == task_id)
+    rest = [t for t in ordered if t.get("id") != task_id]
+    index = next(i for i, t in enumerate(rest) if t.get("id") == anchor_id) + (1 if after else 0)
+    return [*rest[:index], task, *rest[index:]]
+
+
+def insert_position(tasks: list[Any], phase: int) -> int:
+    """Index where a new task of ``phase`` goes: after the last task of that or any earlier phase."""
+    last = -1
+    for index, task in enumerate(tasks):
+        if isinstance(task, dict) and phase_of(task) <= phase:
+            last = index
+    return last + 1

taskgate/render.py

@@ -0,0 +1,39 @@
+"""Markdown view of the registry (drift-checked by ``render --check``)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .config import Config
+from .model import phase_of
+
+HEADER_NOTE = "<!-- GENERATED by `taskgate render` from tasks.json. DO NOT EDIT BY HAND. -->"
+
+BADGES = {
+    "draft": "draft",
+    "planned": "planned",
+    "in_progress": "in-progress",
+    "in_review": "in-review",
+    "blocked": "**blocked**",
+    "done": "done",
+    "cancelled": "cancelled",
+}
+
+
+def render(data: dict[str, Any], config: Config) -> str:
+    """Render the registry as Markdown tables grouped by phase."""
+    tasks = [t for t in data.get("tasks", []) if isinstance(t, dict)]
+    lines = [f"# {config.title}", "", HEADER_NOTE, ""]
+    if not tasks:
+        lines += ["_(no tasks)_", ""]
+    for phase in sorted({phase_of(t) for t in tasks}):
+        group = [t for t in tasks if phase_of(t) == phase]
+        done = sum(1 for t in group if t.get("status") == "done")
+        label = config.phase_names.get(phase, f"Phase {phase}")
+        lines += [f"## {label} ({done}/{len(group)} done)", "", "| ID | Status | Owner | Title |", "| --- | --- | --- | --- |"]
+        for t in group:
+            info = str(t.get("blocked_reason") or t.get("title", "")).replace("|", "\\|")
+            status = str(t.get("status", "?"))
+            lines.append(f"| {t.get('id', '?')} | {BADGES.get(status, status)} | {t.get('owner') or '-'} | {info} |")
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"

taskgate/store.py

@@ -0,0 +1,143 @@
+"""Concurrency-safe storage for the task registry (JSON + JSONL log).
+
+Files under ``<root>/<data_dir>/`` (default ``.taskgate/``):
+
+- ``tasks.json``       -- source of truth (commit it; edit through the CLI)
+- ``tasks.log.jsonl``  -- append-only mutation log ({op, task, at, by, detail})
+- ``tasks.md``         -- generated Markdown view
+- ``.lock``            -- lock file serializing read-modify-write
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import sys
+import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import IO, Any
+
+from . import config as config_mod
+from . import render
+from .config import Config
+
+
+@dataclass(frozen=True)
+class Project:
+    """A located project: its root directory and configuration."""
+
+    root: Path
+    config: Config
+
+    @property
+    def data_dir(self) -> Path:
+        """Directory holding the registry files."""
+        return self.root / self.config.data_dir
+
+    @property
+    def tasks_file(self) -> Path:
+        """Path of the JSON registry."""
+        return self.data_dir / "tasks.json"
+
+    @property
+    def log_file(self) -> Path:
+        """Path of the append-only JSONL log."""
+        return self.data_dir / "tasks.log.jsonl"
+
+    @property
+    def view_file(self) -> Path:
+        """Path of the generated Markdown view."""
+        return self.data_dir / "tasks.md"
+
+
+def open_project(*, create: bool = False) -> Project:
+    """Locate the project (``create`` = ``init``: use the current directory or ``TASKGATE_ROOT``)."""
+    root = config_mod.init_root() if create else config_mod.find_root()
+    return Project(root, config_mod.load(root))
+
+
+def now() -> str:
+    """ISO-8601 UTC timestamp with second precision."""
+    return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
+
+
+if sys.platform == "win32":
+    import msvcrt
+
+    def _lock(fh: IO[bytes]) -> None:
+        fh.seek(0)
+        msvcrt.locking(fh.fileno(), msvcrt.LK_LOCK, 1)
+
+    def _unlock(fh: IO[bytes]) -> None:
+        fh.seek(0)
+        msvcrt.locking(fh.fileno(), msvcrt.LK_UNLCK, 1)
+else:
+    import fcntl
+
+    def _lock(fh: IO[bytes]) -> None:
+        fcntl.flock(fh, fcntl.LOCK_EX)
+
+    def _unlock(fh: IO[bytes]) -> None:
+        fcntl.flock(fh, fcntl.LOCK_UN)
+
+
+@contextmanager
+def locked(project: Project) -> Iterator[None]:
+    """Exclusive file lock around registry read-modify-write."""
+    project.data_dir.mkdir(parents=True, exist_ok=True)
+    with (project.data_dir / ".lock").open("a+b") as fh:
+        _lock(fh)
+        try:
+            yield
+        finally:
+            _unlock(fh)
+
+
+def load(project: Project) -> dict[str, Any]:
+    """Load the registry; fails cleanly when not initialized."""
+    path = project.tasks_file
+    if not path.exists():
+        raise SystemExit(f"error: {path} not found -- run 'taskgate init' first")
+    data: dict[str, Any] = json.loads(path.read_text(encoding="utf-8"))
+    return data
+
+
+def save(project: Project, data: dict[str, Any]) -> None:
+    """Atomically write the registry (temp file + os.replace) and refresh the Markdown view."""
+    path = project.tasks_file
+    data["updated"] = now()
+    text = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+    fd, tmp_name = tempfile.mkstemp(dir=path.parent, suffix=".tmp")
+    try:
+        # write through the descriptor and close it before the replace: Windows refuses to replace an open file
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as fh:
+            fh.write(text)
+        os.replace(tmp_name, path)
+    except BaseException:
+        with contextlib.suppress(OSError):
+            os.unlink(tmp_name)
+        raise
+    # keep the view in step with every registry change, so 'render --check' never goes red by itself
+    project.view_file.write_text(render.render(data, project.config), encoding="utf-8")
+
+
+def append_log(project: Project, op: str, task_id: str, by: str, detail: dict[str, Any]) -> None:
+    """Append one mutation event to the JSONL log."""
+    entry = {"op": op, "task": task_id, "at": now(), "by": by, "detail": detail}
+    project.data_dir.mkdir(parents=True, exist_ok=True)
+    with project.log_file.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+def read_seed(path: str | Path) -> list[dict[str, Any]]:
+    """Read a seed file expecting {'tasks': [...]} or a bare task array."""
+    raw = json.loads(Path(path).read_text(encoding="utf-8"))
+    tasks = raw.get("tasks") if isinstance(raw, dict) else raw
+    if not isinstance(tasks, list):
+        raise SystemExit("error: seed file must contain a 'tasks' list")
+    return tasks

taskgate-0.1.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: taskgate
+Version: 0.1.0
+Summary: Gated task registry with an MCP server: strict status flow, verification and review evidence, for Claude Code, Codex, VS Code Copilot and other MCP clients.
+Author: prachwal
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/prachwal/taskgate
+Project-URL: Repository, https://github.com/prachwal/taskgate
+Project-URL: Issues, https://github.com/prachwal/taskgate/issues
+Keywords: mcp,model-context-protocol,task-tracker,agents,workflow,claude-code,codex,copilot
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Dynamic: license-file
+
+# taskgate
+
+A task registry that makes "done" mean something. Tasks move through a strict status flow, and the
+transitions that matter are gated by evidence: a task enters review only with a green verification, and
+closes only with a review from a *different* identity that lists the commands it checked. It ships as a CLI
+and as an MCP server, so coding agents (Claude Code, Codex, VS Code Copilot, Cursor, Gemini CLI) and humans
+work from the same registry.
+
+- stdlib-only, no runtime dependencies; Python 3.11+; Linux, macOS and Windows
+- state is plain files you commit: `tasks.json` (source of truth), an append-only `tasks.log.jsonl` and a
+  generated `tasks.md`
+- one code path: every MCP tool calls the same CLI command a human would run
+
+## Quick start
+
+```sh
+cd your-project
+uvx taskgate init
+uvx taskgate add --id T-1 --title "Parse the header" --verification-cmd "pytest tests/test_header.py"
+uvx taskgate next              # which task may start now
+uvx taskgate claim T-1 --by dev
+```
+
+Add it to your agent (prints a ready-to-paste block; see [docs/clients.md](docs/clients.md)):
+
+```sh
+uvx taskgate config-snippet claude     # also: vscode, codex, cursor, gemini, generic
+```
+
+From a checkout instead of PyPI: `uvx --from /path/to/taskgate taskgate ...`, or
+`taskgate config-snippet claude --from /path/to/taskgate`.
+
+## The flow
+
+```
+draft -> planned -> in_progress -> in_review -> done
+                        |  ^           |
+                        v  |           +--> in_progress   (review rejected)
+                      blocked
+any non-terminal status -> cancelled
+```
+
+| Rule | What it enforces |
+| --- | --- |
+| order | `claim` works only on tasks whose predecessors in the registry are `done` or `cancelled` |
+| phase gate | a task in a later phase waits until every earlier phase is closed and the registry validates |
+| dependencies | `depends_on` tasks must be `done` before the task can start |
+| verification | `in_review` and `done` need a green `verification_result`; the tool stamps who recorded it and when |
+| review | `done` needs a green `review_result` from the reviewer identity, different from the verifier, listing `checks`, recorded after a delay, in the same call as the closing update |
+| fresh evidence | a new verification voids an earlier review; results are never accepted together in one call |
+| planning | adding, moving and re-linking tasks is limited to the `planners` identities; started work is never reordered |
+
+Identities (`--by`, or the `TASKGATE_BY` environment variable, default `human`) are *declared by the caller*.
+This is a process barrier that keeps roles apart and leaves a trail in the log; it is not authentication.
+
+## Configuration
+
+Optional `taskgate.toml` in the project root; every key has a default
+([examples/taskgate.toml](examples/taskgate.toml)).
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `data_dir` | `.taskgate` | where `tasks.json`, `tasks.log.jsonl`, `tasks.md` live |
+| `title` | `Tasks` | heading of the Markdown view |
+| `id_pattern` | `^[A-Za-z][A-Za-z0-9]*-\d+$` | task id regex; a named group `(?P<phase>\d+)` ties the id to the phase |
+| `phase_names` | none | `{0 = "Foundations"}` labels for the view |
+| `planners` | `["human"]` | identities allowed to add, move and re-link tasks |
+| `reviewer` | `"reviewer"` | identity whose `review_result` closes a task |
+| `owners` | any | restrict `owner` values |
+| `require_review` | `true` | `false`: `done` needs only a green verification |
+| `review_delay_seconds` | `60` | minimum time between verification and review |
+| `[quality]` | none | named gates for the `quality_check` tool, each a list of argv arrays |
+
+The project root is `TASKGATE_ROOT` if set, otherwise the nearest ancestor of the working directory that has
+`taskgate.toml` or `.taskgate/`.
+[examples/embersail.toml](examples/embersail.toml) reproduces a stricter real-world setup (ids `P<phase>-NN`,
+architect/human planners) to show the engine is not tied to one convention.
+
+## Commands
+
+`init`, `validate`, `render [--check]`, `next`, `list [--status]`, `claim`, `update`, `add`, `sort`, `move`,
+`depends`, `mcp`, `config-snippet`. `taskgate <command> --help` lists the flags.
+
+Recording evidence, in separate calls:
+
+```sh
+taskgate update T-1 --verification-result '{"ok": true}' --by dev
+taskgate update T-1 --status in_review --by dev
+taskgate update T-1 --status done --by reviewer \
+  --review-result '{"ok": true, "by": "reviewer", "checks": ["pytest -q"]}'
+```
+
+## MCP tools
+
+`task_list`, `task_next`, `task_validate` (read-only, so clients can skip the approval prompt), `task_claim`,
+`task_update`, `task_add`, `task_move`, `task_depends`, `task_sort`, `task_render` and `quality_check`.
+Tool failures come back as `isError` results rather than protocol errors, so an agent sees the reason.
+
+The server speaks newline-delimited JSON-RPC 2.0 over stdio. Run it with `taskgate mcp` or `taskgate-mcp`.
+
+## Development
+
+```sh
+python -m pip install -e ".[dev]"
+ruff check . && mypy && pytest
+```
+
+## Releasing
+
+Pushing to `main` runs the tests on Linux, macOS and Windows and builds the package. If `version` in
+`pyproject.toml` has no `v<version>` tag yet, the workflow publishes to PyPI through trusted publishing and
+creates the tag and GitHub release. To release: bump `version` in `pyproject.toml` and
+`src/taskgate/__init__.py` (a test keeps them equal), add a changelog entry, merge to `main`.
+
+One-time setup, either way: a GitHub environment named `pypi`. Then either store a PyPI API token as the
+repository secret `PYPI_API_TOKEN` (the first release of a new project needs an account-wide token; narrow it
+to the project afterwards), or add a (pending) trusted publisher on PyPI for this repository, workflow
+`ci.yml`, environment `pypi`. With the secret set it is used; without it the workflow falls back to trusted
+publishing.
+
+## Status
+
+Alpha. Not included: synchronization with a forge (GitLab/GitHub issues). It originated in the Embersail
+project's task tooling.
+
+## License
+
+MIT

taskgate-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+taskgate/__init__.py,sha256=KQRurLvJLBB1S11i8bcMmWaZjN4egELAwGOxl437JRQ,81
+taskgate/__main__.py,sha256=_mBTtnO0nj4fpU3qtGFOhFOYYw1KQpKTY5RINDn4mBA,59
+taskgate/cli.py,sha256=1vkhrmgo7R1M0A6UvKb7lbEp-lbGOBCZNlF6z6exUFQ,5817
+taskgate/clients.py,sha256=bFVEDUZfpRqC-q_KAPloiInJgCO-dTTO1w61_202f5M,2289
+taskgate/config.py,sha256=woN9-IJUpaRlHMWtJoWNukw0pEOKaVEJ43OlHUsabpk,5419
+taskgate/model.py,sha256=mMCNPB5UfmbSlnjiPz52D9-VHrVjRFYJ_tfbZ7JA4Y8,6381
+taskgate/ordering.py,sha256=tGsCTCLzmrXZEMmecZdYEHAH7XJf4l4U2tlP6Dra0i4,5122
+taskgate/render.py,sha256=rC9MQHAAF6w5ZpuWhfi3pj__w8f1nlRBsdMzqDH5lVY,1519
+taskgate/store.py,sha256=em2OirUm0Uxvl_du2PxfEUN1niKV0K_52RK7r1lCFk0,4775
+taskgate/commands/__init__.py,sha256=wgYTWnZKXF-4M9ITNDhZMTUJH6_FthcUt_5zGj9NS8I,20
+taskgate/commands/common.py,sha256=P9mus4R67NESbiaoGq2vq1ghdgaP7yOX05SJfCLbiCs,735
+taskgate/commands/flow.py,sha256=VBuCVM_Jre4A5I61Z_HjzwLZht9pPsTUolpgLFqRmvI,13591
+taskgate/commands/plan.py,sha256=A4U8v6Cnh2nExXRb6TZLchgx0TZUklw_Ad-JD6ZTdbc,3703
+taskgate/commands/registry.py,sha256=HJeZYmCvLuGwYIimnIVWw-lRnsqggJXUH9pXckLimJo,2537
+taskgate/mcp/__init__.py,sha256=DPNmcSjY97H_p61aGFQ6sjLLpPNW0TCaEQdiuJtqyQQ,18
+taskgate/mcp/bridge.py,sha256=qHSagZCYbN6quoTxlW8fdF1ZxdSZdlkJwidDZMtU97s,1512
+taskgate/mcp/protocol.py,sha256=F42oWjglCxp3o3lIHex0TWQdOjyklQ6kGOqLZr5OBsQ,2922
+taskgate/mcp/registry.py,sha256=IkHDg-YJIV3I3D7Ix_9-5llPQde0bW7NBAAk4Auf_1E,1324
+taskgate/mcp/server.py,sha256=lC6at5gTFilIFtUPfyqIAn9KZNsGyQD2VozkzewIHVQ,770
+taskgate/mcp/tools.py,sha256=wig9GKsiG8kPK1kOPlMitC8BAVp_Z9ULwzlvuWZR-8o,8488
+taskgate-0.1.0.dist-info/licenses/LICENSE,sha256=jlaUGO2RF00wZygs00x6e-BvTrCA0ItRm6dbOiD7fhs,1065
+taskgate-0.1.0.dist-info/METADATA,sha256=UduwINQFUPGmJC6yre2NNAB1m9kzfaYZrLkztQ1rZzk,7245
+taskgate-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+taskgate-0.1.0.dist-info/entry_points.txt,sha256=P7H-jPTXFEwyvFLaBxXx048TcL9iciUpgfpar3H31Ko,85
+taskgate-0.1.0.dist-info/top_level.txt,sha256=aIqc3CrLLTaF6B2gaHU4yRCH0LZNX7OPK6dJHYLMh0U,9
+taskgate-0.1.0.dist-info/RECORD,,

taskgate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

taskgate-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+taskgate = taskgate.cli:run
+taskgate-mcp = taskgate.mcp.server:run

taskgate-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 prachwal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.