taskops-cli 0.2.0__py3-none-any.whl

taskops/render/reports.py

@@ -0,0 +1,57 @@
+"""The time-window reports: a standup, and who is live.
+
+Both answer "what is going on" rather than "what should I do", and both are generated —
+which is the claim worth protecting. A standup nobody typed cannot be out of date, and it
+cannot flatter anybody either.
+"""
+
+from __future__ import annotations
+
+from ..contracts import Fleet, Standup
+from ._text import ago, bullet, table, truncate
+
+__all__ = ["render_standup", "render_fleet"]
+
+
+def render_standup(standup: Standup) -> str:
+    """What changed in the window, per actor, then what needs a human."""
+    if not standup["events"]:
+        return "# standup\n\nNothing happened in this window."
+    parts = [f"# standup — {len(standup['events'])} event(s), "
+             f"{len(standup['actors'])} actor(s)", ""]
+    for actor in standup["actors"]:
+        mine = [e for e in standup["events"] if e["actor"] == actor]
+        kinds = sorted({e["kind"] for e in mine})
+        parts.append(f"**{actor}** — {len(mine)} event(s): {', '.join(kinds)}")
+    parts += ["", f"Done: {len(standup['done'])} · in flight: "
+                  f"{len(standup['in_flight'])} · blocked: {len(standup['blocked'])}"]
+    return "\n".join(parts + _needs_a_human(standup))
+
+
+def _needs_a_human(standup: Standup) -> list[str]:
+    """Blocked tasks, called what they are.
+
+    A standup's real job is surfacing the thing no agent can resolve. Listing blocked
+    tasks under a neutral heading buries them among the counts; naming the ask is what
+    makes a human read the section.
+    """
+    if not standup["blocked"]:
+        return []
+    return ["", "### Blocked — needs a human", "",
+            bullet([f"{t['id']} — {truncate(t['title'], 60)}"
+                    for t in standup["blocked"]])]
+
+
+def render_fleet(fleet: Fleet) -> str:
+    """Who is live, and who has gone quiet while still holding a claim.
+
+    A silent member is SHOWN, never filtered out: a claim nobody is honouring is exactly
+    the row somebody needs to act on, and hiding it is how a board loses its credibility.
+    """
+    if not fleet["members"]:
+        return "# fleet\n\nNo live claims."
+    rows = [[m["actor"], m["task"], "yes" if m["alive"] else "SILENT",
+             ago(m["last_seen"]), truncate(m["doing"] or "—", 40)]
+            for m in fleet["members"]]
+    return "\n".join([f"# fleet — {len(fleet['members'])} live claim(s)", "",
+                      table(["actor", "task", "alive", "last seen", "doing"], rows)])

taskops/render/results.py

@@ -0,0 +1,96 @@
+"""What an ACTION returns — a plan, a claim, an update.
+
+Different from a board: the reader just did something and needs to know what happened and
+what to do next, so every one of these ends with the consequence rather than a summary.
+"""
+
+from __future__ import annotations
+
+from ..contracts import EditResult, NextResult, PlanResult, Task, UpdateResult
+from ._text import bullet, table, truncate
+from .task import render_claim
+
+__all__ = ["render_plan", "render_next", "render_update", "render_search", "render_edit"]
+
+
+def render_plan(result: PlanResult) -> str:
+    """The ids created, in the order the caller listed them.
+
+    In ORDER because the caller has its own plan in mind and needs to map ids onto it;
+    sorting by priority here would silently break that correspondence.
+    """
+    rows = [[task["id"], truncate(task["title"], 50), str(task["priority"]),
+             ", ".join(d["task"] for d in result["deps"]
+                       if d["blocks"] == task["id"]) or "—"]
+            for task in result["created"]]
+    return "\n".join([f"# planned {len(result['created'])} task(s)", "",
+                      table(["id", "title", "pri", "after"], rows), "",
+                      _readiness(result)])
+
+
+def _readiness(result: PlanResult) -> str:
+    """The one line worth reading twice.
+
+    A plan where NOTHING is ready is almost always a mistake in the `after` references —
+    a cycle, or an index off by one — and it is invisible until the first `next` returns
+    nothing. Saying it here turns a puzzle twenty minutes later into a sentence now.
+    """
+    if result["unblocked"]:
+        return f"{len(result['unblocked'])} ready to start now"
+    return ("⚠ NOTHING is ready — every task waits on another. Check the `after` "
+            "references for a cycle or an off-by-one index")
+
+
+def render_next(result: NextResult) -> str:
+    """A claim, or the reason there is none — never a bare "nothing available"."""
+    if result["claim"] is not None:
+        return render_claim(result["claim"])
+    return "\n".join(["# nothing to claim", "", result["reason"], "",
+                      f"_{result['ready']} ready · {result['working']} in flight · "
+                      f"{result['blocked']} waiting_"])
+
+
+def render_search(tasks: list[Task], query: str) -> str:
+    """Search results, or a sentence saying nothing matched.
+
+    A sentence rather than an empty list: an agent shown nothing cannot tell a failed search
+    from a genuinely empty project, and it will retry the same query. Ends by naming the
+    next call, because a list of ids without one invites the agent to guess at the tool.
+    """
+    if not tasks:
+        return (f"nothing matches `{query}` — check the board with taskops_report, or plan "
+                f"the work if it does not exist yet")
+    lines = [f"- {t['id']} ({t['status']}) — {truncate(t['title'], 60)}" for t in tasks]
+    return "\n".join([f"{len(tasks)} task(s) matching `{query}`:", "", *lines, "",
+                      "Read one in full with taskops_ask task=<id>."])
+
+
+def render_edit(result: EditResult) -> str:
+    """Which fields moved, and the title as it now reads.
+
+    Says nothing changed when nothing did, rather than printing a card that looks edited:
+    the whole risk of an edit command is believing a rewrite landed when the value passed
+    was the value already stored.
+    """
+    task = result["task"]
+    if not result["changed"]:
+        return f"{task['id']} — nothing changed; the values passed were already stored"
+    return "\n".join([f"{task['id']} — edited {', '.join(result['changed'])}", "",
+                      f"{truncate(task['title'], 70)}  (priority {task['priority']})"])
+
+
+def render_update(result: UpdateResult) -> str:
+    """The new status, and what it set free.
+
+    The unblocked list is the point: an agent that just closed a task learns what it
+    handed to the fleet, which is the difference between finishing work and finishing
+    work somebody can pick up.
+    """
+    parts = [f"{result['task']['id']} → {result['task']['status']}"]
+    if result["unblocked"]:
+        parts += ["", f"Unblocked {len(result['unblocked'])} task(s):",
+                  bullet([f"{t['id']} — {truncate(t['title'], 60)}"
+                          for t in result["unblocked"]])]
+    if result["notified"]:
+        parts += ["", f"Notified: {', '.join(result['notified'])}"]
+    return "\n".join(parts)

taskops/render/session.py

@@ -0,0 +1,75 @@
+"""What a HOOK prints. A different audience from everything else in `render/`.
+
+These two outputs are not read by a person choosing what to do next — they are injected
+into a session's context by SessionStart, or shown to an agent as the reason its commit
+was denied. So they are short, they lead with the action, and they never include anything
+the agent cannot act on. A brief that pastes a whole board costs every session the tokens
+to read a board it did not ask for.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from ..contracts import Event, Lease
+from ._text import ago, bullet, truncate
+
+__all__ = ["render_brief", "render_verdict"]
+
+
+class BriefLike(Protocol):
+    """What `render_brief` needs, structurally.
+
+    A Protocol so `render/` never imports `usecases.Brief` — that would point layer 4 at
+    layer 5 and break the rule that keeps rendering testable from literals. The FIELDS are
+    real contracts, though: `Lease` and `Event` live in layer 1, so typing them properly
+    costs nothing and a loose `dict[str, object]` here was hiding real key errors.
+    """
+
+    actor: str
+    held: list[Lease]
+    messages: list[Event]
+    ready: int
+
+
+class VerdictLike(Protocol):
+    allowed: bool
+    reason: str
+    task: str
+
+
+def render_brief(brief: BriefLike) -> str:
+    """The SessionStart injection: who you are, what you hold, who spoke to you.
+
+    Returns "" when there is nothing at all — no tasks, no messages. A session that is
+    told "you are dev:berna and you hold nothing" has paid tokens to learn nothing, and a
+    hook that prints nothing is a hook that costs nothing.
+    """
+    parts: list[str] = []
+    if brief.held:
+        parts += [f"You ({brief.actor}) hold {len(brief.held)} task(s):",
+                  bullet([f"{lease['task']}"
+                          + (f" on `{lease['branch']}`" if lease["branch"] else
+                             " — no branch yet")
+                          for lease in brief.held])]
+    if brief.messages:
+        parts += ["", f"📬 {len(brief.messages)} message(s):",
+                  bullet([f"{m['actor']} on {m['task']} ({ago(m['ts'])}): "
+                          f"{truncate(str(m['body'].get('text', '')), 100)}"
+                          for m in brief.messages])]
+    if not parts and brief.ready:
+        return f"taskops: {brief.ready} task(s) ready. Run taskops_next to claim one."
+    if not parts:
+        return ""
+    return "taskops — " + "\n".join(parts)
+
+
+def render_verdict(verdict: VerdictLike) -> str:
+    """The commit guard's answer, as the agent reads it in a denial.
+
+    Only the reason. The agent asked to commit and was refused, so the one useful thing is
+    what to do instead — anything else buries it.
+    """
+    if verdict.allowed:
+        return ""
+    return f"taskops: commit blocked — {verdict.reason}"

taskops/render/task.py

@@ -0,0 +1,88 @@
+"""One task, rendered for the agent about to work on it.
+
+The ORDER is the design. An agent reads top-down and may stop early, so what it must not
+miss comes first: what this is, then what would make it collide with somebody, then the
+spec, then the conversation. A collision warning below a long spec is a section an agent
+skims past — and the cost of missing it is two agents rewriting each other's work.
+"""
+
+from __future__ import annotations
+
+from ..contracts import Claim, TaskView
+from ._sections import commits_section, thread_section
+from ._text import STATUS_MARK, bullet, truncate
+from .inbox import render_inbox
+
+__all__ = ["render_view", "render_claim"]
+
+
+def render_claim(claim: Claim) -> str:
+    """A fresh claim: the exact branch command, the inbox, then the task."""
+    task = claim["view"]["task"]
+    head = [f"# {task['id']} — {task['title']}", "",
+            "Claimed. Create the branch and work there:", "",
+            f"    git switch -c {claim['branch']}", ""]
+    messages = render_inbox(claim["inbox"])
+    return "\n".join(head + ([messages, ""] if messages else [])) \
+        + render_view(claim["view"])
+
+
+def render_view(view: TaskView) -> str:
+    """The task in full. Used by `ask`, and by `next` under the claim header."""
+    task = view["task"]
+    parts = [f"## {STATUS_MARK.get(task['status'], '?')} {task['status']} · "
+             f"priority {task['priority']}" + _lease_line(view), ""]
+    parts += _collisions(view)
+    parts += ["### Spec", "", task["spec"] or "_(no spec — ask before guessing)_", ""]
+    parts += _graph(view)
+    parts += thread_section(view["thread"])
+    parts += commits_section(view)
+    return "\n".join(parts)
+
+
+def _lease_line(view: TaskView) -> str:
+    lease = view["lease"]
+    if lease is None:
+        return ""
+    where = f" on `{lease['branch']}`" if lease["branch"] else ""
+    return f" · held by {lease['actor']}{where}"
+
+
+def _collisions(view: TaskView) -> list[str]:
+    """Who else is in these files, and what to do about it.
+
+    The one section that changes what an agent does BEFORE it starts. It ends with the
+    action rather than the observation: told only that somebody else is in the file, an
+    agent proceeds anyway.
+    """
+    others = view["neighbours"]
+    if not others:
+        return []
+    lines = [f"{o['id']} ({o['status']}, {o['created_by']}) — {truncate(o['title'], 50)}"
+             for o in others]
+    return ["### ⚠ Also touching these files", "", bullet(lines), "",
+            "_Message them with taskops_update mentions=… before editing shared files._",
+            ""]
+
+
+def _graph(view: TaskView) -> list[str]:
+    """Both directions of the DAG, plus the subtasks.
+
+    "Blocking N" is stated as a count in the heading on purpose: it is the argument for
+    finishing this today rather than tomorrow, and a number reads as urgency where a
+    bare list reads as trivia.
+    """
+    out: list[str] = []
+    if view["blocked_by"]:
+        out += ["### Waiting on", "",
+                bullet([f"{t['id']} ({t['status']}) — {truncate(t['title'], 60)}"
+                        for t in view["blocked_by"]]), ""]
+    if view["blocks"]:
+        out += [f"### Blocking {len(view['blocks'])} task(s)", "",
+                bullet([f"{t['id']} — {truncate(t['title'], 60)}"
+                        for t in view["blocks"]]), ""]
+    if view["children"]:
+        out += ["### Subtasks", "",
+                bullet([f"{STATUS_MARK.get(t['status'], '?')} {t['id']} — "
+                        f"{truncate(t['title'], 60)}" for t in view["children"]]), ""]
+    return out

taskops/render/tasklist.py

@@ -0,0 +1,65 @@
+"""The task list as ONE line per card — what `taskops tasks` prints.
+
+`render.board` answers "what is the state of the work": eight columns, always all of them,
+because a missing column reads as a bug. This answers a different question — "what is on
+my list" — so the columns collapse into a single ordered list. A reader scanning for an id
+does not want a heading and a table rule between every second row.
+
+Open cards lead, always: that is the question nine times out of ten, and closed ones
+accumulate for the life of a project, so listing them by default would push the answer off
+the screen. But a project whose cards are ALL closed used to print `no open tasks (6 in
+total)` and nothing else — the same mistake the board fixed by never hiding a column. A
+reader who cannot see the finished work cannot tell whether the tool lost it or whether the
+project is done, so with nothing open the closed cards are what this prints, under a
+heading that says which they are. `--all` shows both groups, `--status` picks exactly one.
+"""
+
+from __future__ import annotations
+
+from .._types import CLOSED_STATUSES, OPEN_STATUSES
+from ..contracts import Board
+from ._tasklist import capped, lines, summary
+
+__all__ = ["render_tasklist"]
+
+Section = tuple[str, list[str]]
+
+
+def render_tasklist(board: Board, *, show_all: bool = False,
+                    status: str | None = None) -> str:
+    """A line per task, then one summary line. See the module docstring for which tasks.
+
+    `status` is trusted here — the caller validates it, because naming the legal values in
+    a refusal is an edge's job and this renderer is reached by three of them.
+    """
+    if status is not None:
+        rows = lines(board, frozenset({status}), dated=status in CLOSED_STATUSES)
+        if not rows:
+            return f"no {status} tasks ({board['total']} in total)"
+        return _joined([(f"## {status} ({len(rows)})", rows)], board,
+                       closed=len(rows) if status in CLOSED_STATUSES else 0)
+    open_rows = lines(board, OPEN_STATUSES)
+    closed_rows = lines(board, CLOSED_STATUSES, dated=True)
+    if show_all:
+        return _joined([("## open", open_rows), ("## closed", closed_rows)], board,
+                       closed=len(closed_rows))
+    if open_rows:
+        return _joined([("", open_rows)], board, closed=0)
+    if not closed_rows:
+        return f"no open tasks ({board['total']} in total)"
+    return _joined([("## nothing open — closed tasks, newest first", closed_rows)],
+                   board, closed=len(closed_rows))
+
+
+def _joined(sections: list[Section], board: Board, *, closed: int) -> str:
+    """Headed groups, each capped, then the summary.
+
+    The heading is "" for the ordinary open list, which is how that case keeps the shape it
+    has always had: a heading over the only group on the page is a line that says nothing.
+    """
+    parts: list[str] = []
+    for heading, rows in sections:
+        if heading:
+            parts += [heading, ""]
+        parts += (capped(rows) if rows else ["_none_"]) + [""]
+    return "\n".join([*parts, summary(board, closed)])

taskops/storage/__init__.py

@@ -0,0 +1,36 @@
+"""Layer 2 — the database, and the only package that writes SQL.
+
+`sync` is exported alongside `Store` because the two are one story: the SQLite file
+is a cache of the committed log, and `sync` is what makes that true in both
+directions.
+"""
+
+from __future__ import annotations
+
+from .locate import (
+    DB_FILE,
+    GUIDE_FILE,
+    LOG_FILE,
+    PROJECT_DIR,
+    REPORTS_DIR,
+    find_root,
+    resolve_root,
+)
+from .store import BUSY_TIMEOUT, Store
+from .sync import all_events, event_from, export_events, import_events
+
+__all__ = [
+    "Store",
+    "BUSY_TIMEOUT",
+    "PROJECT_DIR",
+    "DB_FILE",
+    "LOG_FILE",
+    "GUIDE_FILE",
+    "REPORTS_DIR",
+    "find_root",
+    "resolve_root",
+    "export_events",
+    "import_events",
+    "all_events",
+    "event_from",
+]

taskops/storage/_ddl.py

@@ -0,0 +1,78 @@
+"""The tables, as SQL. Data, not logic — which is why it is not in `schema.py`.
+
+That module is the part with bugs in it: pragmas, ALTERs, tolerating exactly one
+kind of failure. This one is a declaration, and keeping them apart means a review
+of a migration is not also a review of sixty lines of unchanged DDL.
+"""
+
+from __future__ import annotations
+
+__all__ = ["DDL"]
+
+DDL = """
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    spec TEXT NOT NULL DEFAULT '',
+    status TEXT NOT NULL,
+    priority INTEGER NOT NULL DEFAULT 2,
+    parent TEXT,
+    labels TEXT NOT NULL DEFAULT '[]',      -- JSON array
+    files TEXT NOT NULL DEFAULT '[]',       -- JSON array
+    created_by TEXT NOT NULL,
+    assignee TEXT NOT NULL DEFAULT '',
+    created REAL NOT NULL,
+    updated REAL NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent);
+CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee);
+
+-- `task` must finish before `blocks` can start. Queried from BOTH ends, so both
+-- directions are indexed: the primary key covers one, idx_deps_blocks the other.
+CREATE TABLE IF NOT EXISTS deps (
+    task TEXT NOT NULL,
+    blocks TEXT NOT NULL,
+    PRIMARY KEY (task, blocks)
+);
+CREATE INDEX IF NOT EXISTS idx_deps_blocks ON deps(blocks);
+
+-- `task` is the PRIMARY KEY, and that is the entire locking story: two agents
+-- racing to claim one task are two INSERTs on one key, and SQLite settles it.
+CREATE TABLE IF NOT EXISTS leases (
+    task TEXT PRIMARY KEY,
+    actor TEXT NOT NULL,
+    session TEXT NOT NULL DEFAULT '',
+    branch TEXT NOT NULL DEFAULT '',
+    acquired REAL NOT NULL,
+    expires REAL NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_leases_actor ON leases(actor);
+
+-- seq orders events on THIS machine; ts orders them across machines. Both are
+-- needed: seq is what a live feed streams from, ts is what survives a sync.
+CREATE TABLE IF NOT EXISTS events (
+    id TEXT PRIMARY KEY,                    -- the content, hashed: import twice = no-op
+    seq INTEGER,
+    task TEXT NOT NULL,
+    actor TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    body TEXT NOT NULL DEFAULT '{}',        -- JSON object, shaped by kind
+    ts REAL NOT NULL,
+    exported INTEGER NOT NULL DEFAULT 0     -- has the committed log seen this one
+);
+CREATE INDEX IF NOT EXISTS idx_events_task ON events(task, ts);
+CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind, ts);
+CREATE INDEX IF NOT EXISTS idx_events_export ON events(exported);
+
+-- Delivery is per (actor, event), never a timestamp cursor: an agent's hooks fire
+-- in an order nobody controls, and a cursor would skip whatever arrived late.
+CREATE TABLE IF NOT EXISTS delivered (
+    actor TEXT NOT NULL,
+    event TEXT NOT NULL,
+    ts REAL NOT NULL,
+    PRIMARY KEY (actor, event)
+);
+
+CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT);
+"""

taskops/storage/_delivered.py

@@ -0,0 +1,51 @@
+"""Who has been shown what — the inbox's memory.
+
+A per-pair table rather than a `last_seen` timestamp per actor. The reason is the
+delivery path: an agent's messages reach it through whichever hook fires first, in
+an order nobody controls, and events arrive from two replication paths with
+timestamps set by two machines. A cursor would advance past a message that landed
+a second late and that message would never be delivered — silently, which is the
+worst way for a coordination system to fail.
+
+The cost is one row per (actor, message). Bounded by conversation volume, not by
+event volume: only directed kinds are ever tracked here.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+from ..contracts import Event
+from ._rows import to_event
+
+__all__ = ["DeliveredTable"]
+
+
+class DeliveredTable:
+    def __init__(self, db: sqlite3.Connection) -> None:
+        self.db = db
+
+    def pending(self, actor: str, *, limit: int = 50) -> list[Event]:
+        """Directed events this actor has not been shown, oldest first.
+
+        "Directed at" is `mentions` containing the actor id, matched in SQL with a
+        LIKE over the JSON body. Crude and deliberate: the alternative is a
+        mentions join table, and a mention is read once and never queried by
+        anything else — so the join table would exist purely to make this one
+        LIKE prettier. Substring collision is prevented by quoting: the body
+        stores `"agent:ana/api-1"` with its quotes, so `dev:an` cannot match
+        `dev:ana`.
+        """
+        rows = self.db.execute(
+            'SELECT e.* FROM events e WHERE e.kind IN ("message", "handoff") '
+            "AND e.body LIKE ? AND NOT EXISTS ("
+            "  SELECT 1 FROM delivered d WHERE d.actor = ? AND d.event = e.id) "
+            "ORDER BY e.ts, e.seq LIMIT ?",
+            (f'%"{actor}"%', actor, limit)).fetchall()
+        return [to_event(row) for row in rows]
+
+    def mark(self, actor: str, ids: list[str], *, when: float) -> None:
+        """Record delivery. Idempotent, so re-running a hook costs nothing."""
+        self.db.executemany(
+            "INSERT OR IGNORE INTO delivered (actor, event, ts) VALUES (?, ?, ?)",
+            [(actor, event_id, when) for event_id in ids])

taskops/storage/_deps.py

@@ -0,0 +1,69 @@
+"""The dependency edges. `task` must finish before `blocks` can start."""
+
+from __future__ import annotations
+
+import sqlite3
+
+from .._types import CLOSED_STATUSES
+from ..contracts import Dep
+
+__all__ = ["DepTable"]
+
+
+class DepTable:
+    def __init__(self, db: sqlite3.Connection) -> None:
+        self.db = db
+
+    def add(self, task: str, blocks: str) -> None:
+        """Idempotent: the same edge asserted twice is the same fact."""
+        self.db.execute("INSERT OR IGNORE INTO deps (task, blocks) VALUES (?, ?)", (task, blocks))
+
+    def remove(self, task: str, blocks: str) -> None:
+        self.db.execute("DELETE FROM deps WHERE task=? AND blocks=?", (task, blocks))
+
+    def all(self) -> list[Dep]:
+        rows = self.db.execute("SELECT task, blocks FROM deps").fetchall()
+        return [Dep(task=str(r["task"]), blocks=str(r["blocks"])) for r in rows]
+
+    def blockers_of(self, task_id: str) -> list[str]:
+        """Every id this task waits on, closed or not."""
+        rows = self.db.execute("SELECT task FROM deps WHERE blocks=?", (task_id,)).fetchall()
+        return [str(row["task"]) for row in rows]
+
+    def dependents_of(self, task_id: str) -> list[str]:
+        """Every id waiting on this one."""
+        rows = self.db.execute("SELECT blocks FROM deps WHERE task=?", (task_id,)).fetchall()
+        return [str(row["blocks"]) for row in rows]
+
+    def open_blockers_of(self, task_id: str) -> list[str]:
+        """The blockers that are still open — the ones that actually block.
+
+        A JOIN rather than two queries and a filter in Python: this runs for every
+        task in the ready-set computation, and the ready-set is recomputed after
+        every write in the system.
+        """
+        marks = ", ".join("?" * len(CLOSED_STATUSES))
+        closed = tuple(sorted(CLOSED_STATUSES))
+        rows = self.db.execute(
+            f"SELECT d.task FROM deps d JOIN tasks t ON t.id = d.task "
+            f"WHERE d.blocks = ? AND t.status NOT IN ({marks})",
+            (task_id, *closed),
+        ).fetchall()
+        return [str(row["task"]) for row in rows]
+
+    def unblocked_by(self, task_id: str) -> list[str]:
+        """Ids that have NO open blocker left once `task_id` is closed.
+
+        Asked after a task closes, so `task_id` is already closed in the same
+        transaction — which is why this needs no special case for it. The
+        NOT EXISTS reads as the question: dependents with nothing open left.
+        """
+        marks = ", ".join("?" * len(CLOSED_STATUSES))
+        closed = tuple(sorted(CLOSED_STATUSES))
+        rows = self.db.execute(
+            f"SELECT d.blocks AS id FROM deps d WHERE d.task = ? AND NOT EXISTS ("
+            f"  SELECT 1 FROM deps o JOIN tasks t ON t.id = o.task"
+            f"  WHERE o.blocks = d.blocks AND t.status NOT IN ({marks}))",
+            (task_id, *closed),
+        ).fetchall()
+        return [str(row["id"]) for row in rows]