Use when: you need to discover which projects are registered before calling
``status``, ``build``, or ``run`` on a specific one. Do NOT use when: the
project isn't registered yet — call ``scan`` first to register it. Related:
``scan`` (register projects), ``status`` (inspect one project). Takes no
parameters.

Side effects: none — read-only, calls no LLM, and returns the same result on
repeated calls (idempotent).

Returns a mapping of project id to an object with its registered ``path`` and
``name``; an empty mapping when nothing is registered.

Use when: you want to inspect what work exists and how far it has progressed,
e.g. before deciding whether to ``run`` pending tasks or ``build`` new work.
Do NOT use when: the project isn't registered — call ``scan`` first, or
``list_projects`` to find the right path. Related: ``list_projects``,
``run``, ``build``.

Side effects: none — read-only, calls no LLM, idempotent.

Returns the project's tasks, each with its id, title, and status.

Use when: you have projects on disk that misterdev does not know about yet,
before calling ``status``, ``build``, or ``run`` on them. Do NOT use when:
the projects are already registered (call ``list_projects`` to check) — a
re-scan is harmless but redundant. Related: ``list_projects`` (see what is
registered), ``status`` (inspect a registered project).

Side effects: writes only to misterdev's project registry — it never reads,
edits, or executes any project code, and re-scanning the same directory is
idempotent (no duplicates).

Returns a short confirmation string naming the directory scanned.

Use when: you have a goal but no existing task plan — ``build`` analyzes the
project, decomposes ``goal`` into tasks, edits the code, and verifies each
change through build/test/lint/typecheck gates, reverting anything that
regresses. Do NOT use when: a task plan already exists and you just want to
execute it (use ``run``), or the working tree is dirty (commit/stash first).
Related: ``run`` (execute an existing plan), ``status`` (inspect tasks).

DESTRUCTIVE side effects: edits files and makes git commits, and calls an
external LLM provider (open-world, non-idempotent). It refuses to run on a
dirty working tree. ``dry_run=True`` previews without changing anything;
``budget`` caps spend; ``max_tasks`` caps scope.

Returns a compact text report: what was done, per-gate results, and cost.

Use when: tasks already exist (from a prior ``plan`` or a devplan directory)
and you want to execute them. Do NOT use when: no plan exists and you are
starting from a goal — that is ``build``'s job (it analyzes and decomposes).
Related: ``build`` (plan + execute a goal), ``status`` (see the task ids).
Pass ``task_id`` to run a single task.

DESTRUCTIVE side effects: edits files and makes git commits, and calls an
external LLM provider (open-world, non-idempotent). ``dry_run=True`` previews
without changing anything.

Returns a short text summary of what was run or previewed.