minitest-cli 0.36.0__tar.gz → 0.37.0__tar.gz

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/.env.example

@@ -16,6 +16,12 @@ MINITEST_API_URL=https://testing-service.dev.minitap.ai
 # Development
 MINITEST_APPS_MANAGER_URL=https://apps-manager.dev.minitap.ai
 
+# —— Conductor (minitest draft) ——
+# Production
+# MINITEST_CONDUCTOR_URL=https://conductor.app.minitap.ai
+# Development
+MINITEST_CONDUCTOR_URL=https://conductor.dev.minitap.ai
+
 # —— Integrations ——
 # Production
 # MINITEST_INTEGRATIONS_URL=https://integrations.minitap.ai

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.36.0
+Version: 0.37.0
 Summary: Minitest CLI – command-line interface for the Minitest testing platform
 Project-URL: Homepage, https://minitap.ai/
 Project-URL: Source, https://github.com/minitap-ai/minitest-cli
@@ -145,6 +145,7 @@ app defaults.
 | `MINITEST_APP_ID`             | Default app ID                                             | No (can use `--app` flag)          |
 | `MINITEST_API_URL`            | testing-service base URL                                   | No (defaults to production)        |
 | `MINITEST_APPS_MANAGER_URL`   | apps-manager base URL (used by `minitest apps create`)     | No (defaults to production)        |
+| `MINITEST_CONDUCTOR_URL`      | Conductor base URL (used by `minitest draft`)              | No (defaults to production)        |
 | `MINITEST_INTEGRATIONS_URL`   | minihands-integrations base URL (used to list tenants)     | No (defaults to production)        |
 | `MINITEST_WEBAPP_URL`         | Minitest webapp base URL (used for review links)            | No (defaults to production)        |
 | `MINITEST_SUPABASE_URL`       | Supabase project URL used for OAuth login                  | No (defaults to production)        |
@@ -169,7 +170,8 @@ app defaults.
 | `minitest apps`  | List, inspect, and create apps; residential proxy and private network settings |
 | `minitest scenario` | Create, update, list and delete scenarios |
 | `minitest scenario-binding` | Bind test accounts, test files or app skills to scenarios |
-| `minitest draft` | Drafts — branches of the test suite |
+| `minitest draft` | Ask Mini for a suite change, follow it, check and merge it (drafts in the webapp) |
+| `minitest df` | Low-level suite branches Mini writes (draft features) |
 | `minitest test-profile` | Test profiles (Test accounts in the webapp) |
 | `minitest tags`  | List, create, update and delete scenario tags |
 | `minitest app-skill` | App skills (Skills in the webapp): procedures Mini loads to arrange test state |
@@ -190,7 +192,7 @@ stderr and leave `--json` stdout unchanged. Switch to the new names.
 | `minitest user-story` | `minitest scenario` |
 | `minitest user-story-binding` | `minitest scenario-binding` |
 | `minitest scenario-binding set-skills` | `minitest scenario-binding set-app-skills` |
-| `minitest df` | `minitest draft` |
+| `minitest draft show/apply/delete` (v0.34–v0.36) | `minitest df show/apply/delete` |
 | `minitest flow-types` | `minitest tags` |
 | `run from-commit --user-story` / `-u` | `run from-commit --scenario` / `-s` |
 | `batch list --user-story-id` | `batch list --scenario` |

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/README.md

@@ -112,6 +112,7 @@ app defaults.
 | `MINITEST_APP_ID`             | Default app ID                                             | No (can use `--app` flag)          |
 | `MINITEST_API_URL`            | testing-service base URL                                   | No (defaults to production)        |
 | `MINITEST_APPS_MANAGER_URL`   | apps-manager base URL (used by `minitest apps create`)     | No (defaults to production)        |
+| `MINITEST_CONDUCTOR_URL`      | Conductor base URL (used by `minitest draft`)              | No (defaults to production)        |
 | `MINITEST_INTEGRATIONS_URL`   | minihands-integrations base URL (used to list tenants)     | No (defaults to production)        |
 | `MINITEST_WEBAPP_URL`         | Minitest webapp base URL (used for review links)            | No (defaults to production)        |
 | `MINITEST_SUPABASE_URL`       | Supabase project URL used for OAuth login                  | No (defaults to production)        |
@@ -136,7 +137,8 @@ app defaults.
 | `minitest apps`  | List, inspect, and create apps; residential proxy and private network settings |
 | `minitest scenario` | Create, update, list and delete scenarios |
 | `minitest scenario-binding` | Bind test accounts, test files or app skills to scenarios |
-| `minitest draft` | Drafts — branches of the test suite |
+| `minitest draft` | Ask Mini for a suite change, follow it, check and merge it (drafts in the webapp) |
+| `minitest df` | Low-level suite branches Mini writes (draft features) |
 | `minitest test-profile` | Test profiles (Test accounts in the webapp) |
 | `minitest tags`  | List, create, update and delete scenario tags |
 | `minitest app-skill` | App skills (Skills in the webapp): procedures Mini loads to arrange test state |
@@ -157,7 +159,7 @@ stderr and leave `--json` stdout unchanged. Switch to the new names.
 | `minitest user-story` | `minitest scenario` |
 | `minitest user-story-binding` | `minitest scenario-binding` |
 | `minitest scenario-binding set-skills` | `minitest scenario-binding set-app-skills` |
-| `minitest df` | `minitest draft` |
+| `minitest draft show/apply/delete` (v0.34–v0.36) | `minitest df show/apply/delete` |
 | `minitest flow-types` | `minitest tags` |
 | `run from-commit --user-story` / `-u` | `run from-commit --scenario` / `-s` |
 | `batch list --user-story-id` | `batch list --scenario` |

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitest-cli"
-version = "0.36.0"
+version = "0.37.0"
 description = "Minitest CLI – command-line interface for the Minitest testing platform"
 readme = "README.md"
 license = "MIT"

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/api/client.py

@@ -39,9 +39,16 @@ class ApiClient:
             response = await client.get("/api/v1/apps")
     """
 
-    def __init__(self, settings: Settings, *, token_override: str | None = None) -> None:
+    def __init__(
+        self,
+        settings: Settings,
+        *,
+        token_override: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
         self._settings = settings
         self._token_override = token_override
+        self._base_url = base_url or settings.api_url
         self._client: httpx.AsyncClient | None = None
 
     async def __aenter__(self) -> "ApiClient":
@@ -53,7 +60,7 @@ class ApiClient:
         if self._settings.cause is not None:
             headers[CAUSE_HEADER] = self._settings.cause
         self._client = httpx.AsyncClient(
-            base_url=self._settings.api_url,
+            base_url=self._base_url,
             headers=headers,
             auth=_BearerAuth(self._settings, self._token_override),
             timeout=DEFAULT_TIMEOUT,

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/commands/apps.py

@@ -30,6 +30,7 @@ from minitest_cli.utils.output import (
     print_table,
 )
 
+EXIT_GENERAL_ERROR = 1
 EXIT_NETWORK_ERROR = 3
 
 app = typer.Typer(name="apps", help="App management.")
@@ -70,6 +71,9 @@ def list_apps() -> None:
                         detail = body.get("detail") or body.get("message") or detail
                 except Exception:  # noqa: BLE001
                     pass
+                if resp.status_code in (401, 403):
+                    print_error(f"Authentication failed ({resp.status_code}): {detail}")
+                    raise typer.Exit(code=EXIT_GENERAL_ERROR)
                 print_error(f"API error ({resp.status_code}): {detail}")
                 raise typer.Exit(code=EXIT_NETWORK_ERROR)
             return AppListResponse.model_validate(resp.json())

minitest_cli-0.37.0/src/minitest_cli/commands/draft.py

@@ -0,0 +1,111 @@
+"""`minitest draft`: ask Mini for a suite change and drive it to merge.
+
+A draft is the workbench the webapp shows under Drafts: a branch of the suite plus
+Mini's conversation about it. Mini is the only author of the branch; never `df apply`
+into a draft's branch yourself.
+"""
+
+from typing import Annotated
+
+import typer
+
+from minitest_cli.commands import (
+    draft_asks,
+    draft_conversation,
+    draft_create,
+    draft_legacy,
+    draft_lifecycle,
+    draft_pr,
+    draft_update,
+)
+from minitest_cli.commands.draft_helpers import (
+    DRAFTS_PATH,
+    call,
+    draft_path,
+    resolve_target,
+    run_conductor,
+)
+from minitest_cli.commands.draft_render import (
+    DRAFT_TABLE_HEADERS,
+    draft_row,
+    show_draft,
+)
+from minitest_cli.commands.draft_watch import WatchUntil, watch
+from minitest_cli.utils.output import (
+    print_info,
+    print_json,
+    print_table,
+)
+
+app = typer.Typer(
+    name="draft",
+    help="Ask Mini for a suite change, follow the conversation, and check/merge the result.",
+    no_args_is_help=True,
+)
+EXIT_WATCH_TIMEOUT = 1
+
+
+@app.command(name="list")
+def list_drafts(
+    history: Annotated[
+        bool, typer.Option("--history", help="List merged and discarded drafts instead.")
+    ] = False,
+) -> None:
+    """List the active app's drafts (open ones by default)."""
+    target = resolve_target()
+    params = {"appId": target.app_id, "scope": "history" if history else "open"}
+    body = call(target, "GET", DRAFTS_PATH, retry=True, params=params)
+    drafts = body.get("drafts", [])
+    if target.json_mode:
+        print_json(drafts)
+        return
+    if not drafts:
+        print_info("No drafts found.")
+        return
+    print_table(
+        DRAFT_TABLE_HEADERS, [draft_row(d) for d in drafts], title=f"Drafts ({len(drafts)})"
+    )
+
+
+@app.command(name="get")
+def get_draft(
+    draft_id: Annotated[str, typer.Argument(help="Draft ID.")],
+    watch_flag: Annotated[
+        bool, typer.Option("--watch", help="Poll until the draft is stable, then print it.")
+    ] = False,
+    until: Annotated[
+        WatchUntil,
+        typer.Option(
+            "--until",
+            help="idle: Mini has nothing queued. settled: also no check or draft build running.",
+        ),
+    ] = WatchUntil.IDLE,
+    interval: Annotated[
+        float, typer.Option("--interval", min=1.0, help="Seconds between polls.")
+    ] = 5.0,
+    timeout: Annotated[
+        float, typer.Option("--timeout", min=1.0, help="Give up after this many seconds (exit 1).")
+    ] = 900.0,
+) -> None:
+    """Show a draft: state, Mini's status, scenarios and open asks."""
+    target = resolve_target()
+    path = draft_path(draft_id)
+    if not watch_flag:
+        show_draft(call(target, "GET", path, retry=True), json_mode=target.json_mode)
+        return
+    draft, stable = run_conductor(
+        watch(target, path, until=until, interval=interval, timeout=timeout)
+    )
+    show_draft(draft, json_mode=target.json_mode)
+    if not stable:
+        print_info(f"Still not {until.value} after {timeout:.0f}s; run the same command again.")
+        raise typer.Exit(code=EXIT_WATCH_TIMEOUT)
+
+
+draft_create.register(app)
+draft_update.register(app)
+draft_conversation.register(app)
+draft_lifecycle.register(app)
+draft_pr.register(app)
+app.add_typer(draft_asks.app)
+draft_legacy.register(app)

minitest_cli-0.37.0/src/minitest_cli/commands/draft_asks.py

@@ -0,0 +1,148 @@
+"""`minitest draft ask list|answer|decline`: answer what Mini asked on a draft.
+
+Secret fields (``secret: true`` in an ask's answerFields) are only read from a file or
+stdin (``--field-file KEY=PATH``, ``-`` for stdin) — never from the command line, where
+shells and process lists keep them — and are never printed back.
+"""
+
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.commands.draft_helpers import (
+    EXIT_GENERAL_ERROR,
+    EXIT_NOT_FOUND,
+    DraftTarget,
+    call,
+    draft_path,
+    resolve_target,
+)
+from minitest_cli.commands.draft_render import (
+    ASK_TABLE_HEADERS,
+    ask_fields,
+    read_file,
+    read_text,
+    show_draft,
+)
+from minitest_cli.commands.run_helpers import ensure_uuid
+from minitest_cli.utils.output import (
+    print_error,
+    print_info,
+    print_json,
+    print_success,
+    print_table,
+)
+
+app = typer.Typer(
+    name="ask", help="Read and answer Mini's questions on a draft.", no_args_is_help=True
+)
+DraftIdArg = Annotated[str, typer.Argument(help="Draft ID.")]
+AskIdArg = Annotated[str, typer.Argument(help="Ask ID (from `draft ask list`).")]
+
+
+def _open_asks(target: DraftTarget, draft_id: str) -> list[dict[str, Any]]:
+    return call(target, "GET", draft_path(draft_id), retry=True).get("asks") or []
+
+
+def _find_ask(target: DraftTarget, draft_id: str, ask_id: str) -> dict[str, Any]:
+    ensure_uuid(ask_id, kind="ask id")
+    for ask in _open_asks(target, draft_id):
+        if ask.get("id") == ask_id:
+            return ask
+    print_error(f"No open ask {ask_id} on draft {draft_id}; see `minitest draft ask list`.")
+    raise typer.Exit(code=EXIT_NOT_FOUND)
+
+
+def _pair(raw: str, flag: str) -> tuple[str, str]:
+    key, sep, value = raw.partition("=")
+    if not sep or not key:
+        print_error(f"{flag} expects KEY=VALUE.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    return key, value
+
+
+def _fields(ask: dict[str, Any], inline: list[str], files: list[str]) -> dict[str, str]:
+    known = {f["key"]: f for f in ask.get("answerFields") or []}
+    values: dict[str, str] = {}
+    for raw in inline:
+        key, value = _pair(raw, "--field")
+        if known.get(key, {}).get("secret"):
+            print_error(f"'{key}' is secret: pass it with --field-file {key}=PATH (- = stdin).")
+            raise typer.Exit(code=EXIT_GENERAL_ERROR)
+        values[key] = value
+    if sum(1 for raw in files if _pair(raw, "--field-file")[1] == "-") > 1:
+        print_error("Only one --field-file can read stdin.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    for raw in files:
+        key, path = _pair(raw, "--field-file")
+        values[key] = read_file(Path(path)).removesuffix("\n")
+    unknown = sorted(set(values) - set(known))
+    if unknown:
+        print_error(f"Unknown field(s) {', '.join(unknown)}; this ask takes: {ask_fields(ask)}.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    return values
+
+
+@app.command(name="list")
+def list_asks(draft_id: DraftIdArg) -> None:
+    """List Mini's open questions on a draft, with the fields each answer takes."""
+    target = resolve_target()
+    asks = _open_asks(target, draft_id)
+    if target.json_mode:
+        print_json(asks)
+        return
+    if not asks:
+        print_info("Mini is not asking anything.")
+        return
+    rows = [[a["id"], a.get("askType", "-"), a["question"], ask_fields(a)] for a in asks]
+    print_table(ASK_TABLE_HEADERS, rows)
+
+
+@app.command(name="answer")
+def answer_ask(
+    draft_id: DraftIdArg,
+    ask_id: AskIdArg,
+    answer: Annotated[str | None, typer.Option("--answer", help="Free-text answer.")] = None,
+    answer_file: Annotated[
+        Path | None, typer.Option("--answer-file", help="Read the answer from a file (- = stdin).")
+    ] = None,
+    field: Annotated[
+        list[str] | None, typer.Option("--field", help="KEY=VALUE for a non-secret field.")
+    ] = None,
+    field_file: Annotated[
+        list[str] | None,
+        typer.Option("--field-file", help="KEY=PATH, value read from a file (- = stdin)."),
+    ] = None,
+) -> None:
+    """Answer an ask; Mini resumes the draft with it. Turns auto-merge off."""
+    text = read_text(answer, answer_file, flag="answer", required=False)
+    target = resolve_target()
+    ask = _find_ask(target, draft_id, ask_id)
+    values = _fields(ask, field or [], field_file or [])
+    if text is None and not values:
+        print_error("Pass --answer/--answer-file, or the ask's fields with --field/--field-file.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    body: dict[str, object] = {}
+    if text is not None:
+        body["answer"] = text
+    if values:
+        body["fields"] = values
+    draft = call(target, "POST", draft_path(draft_id, f"/asks/{ask_id}/answer"), json=body)
+    print_success("Answered; Mini picks it up next.")
+    show_draft(draft, json_mode=target.json_mode)
+
+
+@app.command(name="decline")
+def decline_ask(
+    draft_id: DraftIdArg,
+    ask_id: AskIdArg,
+    reason: Annotated[str | None, typer.Option("--reason", help="Why, so Mini can adapt.")] = None,
+) -> None:
+    """Decline an ask; Mini carries on without it."""
+    target = resolve_target()
+    ensure_uuid(ask_id, kind="ask id")
+    body = {"reason": reason} if reason else None
+    draft = call(target, "POST", draft_path(draft_id, f"/asks/{ask_id}/decline"), json=body)
+    print_success("Declined.")
+    show_draft(draft, json_mode=target.json_mode)

minitest_cli-0.37.0/src/minitest_cli/commands/draft_conversation.py

@@ -0,0 +1,84 @@
+"""`minitest draft message|messages|stop`: talk to Mini about a draft."""
+
+import uuid
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.commands.draft_helpers import call, draft_path, resolve_target
+from minitest_cli.commands.draft_render import MESSAGE_TABLE_HEADERS, read_text
+from minitest_cli.utils.output import print_info, print_json, print_success, print_table
+
+
+def _message_row(message: dict[str, Any]) -> list[str]:
+    return [str(message.get("createdAt", "-")), str(message.get("role", "-")), message["content"]]
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(name="message")
+    def post_message(
+        draft_id: Annotated[str, typer.Argument(help="Draft ID.")],
+        message: Annotated[str | None, typer.Option("--message", help="What to tell Mini.")] = None,
+        message_file: Annotated[
+            Path | None,
+            typer.Option("--message-file", help="Read the message from a file (- = stdin)."),
+        ] = None,
+        client_message_id: Annotated[
+            str | None,
+            typer.Option(
+                "--client-message-id", help="Re-send with the same id to never post it twice."
+            ),
+        ] = None,
+    ) -> None:
+        """Send Mini a follow-up message; Mini answers it in the background, in order."""
+        text = read_text(message, message_file, flag="message", required=True)
+        target = resolve_target()
+        message_id = client_message_id or f"cli-{uuid.uuid4()}"
+        posted = call(
+            target,
+            "POST",
+            draft_path(draft_id, "/messages"),
+            retry=True,
+            json={"message": text, "clientMessageId": message_id},
+        )
+        if target.json_mode:
+            print_json(posted)
+            return
+        verb = "Sent" if posted.get("created") else "Already sent"
+        print_success(f"{verb} (client message id: {message_id}).")
+        print_info(f"Wait for Mini's reply with `minitest draft get {draft_id} --watch`.")
+
+    @app.command(name="messages")
+    def list_messages(
+        draft_id: Annotated[str, typer.Argument(help="Draft ID.")],
+        last: Annotated[
+            int | None, typer.Option("--last", min=1, help="Only the last N messages.")
+        ] = None,
+    ) -> None:
+        """Read the conversation with Mini, oldest first."""
+        target = resolve_target()
+        body = call(target, "GET", draft_path(draft_id, "/messages"), retry=True)
+        messages = body.get("messages", [])
+        if last is not None:
+            messages = messages[-last:]
+        if target.json_mode:
+            print_json(messages)
+            return
+        if not messages:
+            print_info("No messages yet.")
+            return
+        print_table(MESSAGE_TABLE_HEADERS, [_message_row(m) for m in messages])
+
+    @app.command(name="stop")
+    def stop_turn(draft_id: Annotated[str, typer.Argument(help="Draft ID.")]) -> None:
+        """Interrupt what Mini is writing right now."""
+        target = resolve_target()
+        body = call(target, "POST", draft_path(draft_id, "/stop"))
+        if target.json_mode:
+            print_json(body)
+            return
+        if body.get("stopped"):
+            print_success("Mini stopped.")
+        else:
+            print_info("Mini was not writing.")

minitest_cli-0.37.0/src/minitest_cli/commands/draft_create.py

@@ -0,0 +1,66 @@
+"""`minitest draft create`: open a draft with a first message for Mini."""
+
+import uuid
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from minitest_cli.commands.draft_helpers import DRAFTS_PATH, call, resolve_target
+from minitest_cli.commands.draft_render import read_text, show_draft
+from minitest_cli.utils.output import print_info, print_success, print_warning
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(name="create")
+    def create_draft(
+        message: Annotated[
+            str | None, typer.Option("--message", help="What you want Mini to change.")
+        ] = None,
+        message_file: Annotated[
+            Path | None,
+            typer.Option("--message-file", help="Read the message from a file (- = stdin)."),
+        ] = None,
+        title: Annotated[
+            str | None, typer.Option("--title", help="Draft title (Mini names it otherwise).")
+        ] = None,
+        auto_check: Annotated[
+            bool,
+            typer.Option("--auto-check/--no-auto-check", help="Check each change Mini writes."),
+        ] = False,
+        auto_merge: Annotated[
+            bool,
+            typer.Option(
+                "--auto-merge/--no-auto-merge", help="Merge on its own once proven and ready."
+            ),
+        ] = False,
+        idempotency_key: Annotated[
+            str | None,
+            typer.Option(
+                "--idempotency-key", help="Re-run with the same key to get the same draft back."
+            ),
+        ] = None,
+    ) -> None:
+        """Open a draft with a first message; Mini starts working on it right away."""
+        text = read_text(message, message_file, flag="message", required=True)
+        if auto_merge and not auto_check:
+            print_warning(
+                "--auto-merge only merges proven changes; add --auto-check or run `draft check`."
+            )
+        target = resolve_target()
+        key = idempotency_key or f"cli-{uuid.uuid4()}"
+        body: dict[str, object] = {
+            "tenantId": target.tenant_id,
+            "appId": target.app_id,
+            "message": text,
+            "autoCheck": auto_check,
+            "autoMerge": auto_merge,
+            "idempotencyKey": key,
+        }
+        if title is not None:
+            body["title"] = title
+        draft = call(target, "POST", DRAFTS_PATH, retry=True, json=body)
+        print_success(f"Draft {draft['id']} opened; Mini is on it.")
+        print_info(f"Idempotency key: {key} — reuse it with --idempotency-key to retry safely.")
+        print_info(f"Follow it with `minitest draft get {draft['id']} --watch`.")
+        show_draft(draft, json_mode=target.json_mode)

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/commands/draft_feature.py

@@ -1,7 +1,8 @@
-"""Draft-feature commands: list, create, delete.
+"""Low-level draft-feature commands (`minitest df`): list, create, delete.
 
 A draft feature is a branch of the app's test suite — it holds a delta against
 main rather than a copy of it, so `show` is the only way to see what it changes.
+Mini writes these branches; customer agents work with Mini through `minitest draft`.
 """
 
 import json
@@ -11,7 +12,6 @@ import typer
 
 from minitest_cli.api.client import ApiClient
 from minitest_cli.commands import draft_feature_apply, draft_feature_show
-from minitest_cli.commands.deprecated_alias import deprecated_alias
 from minitest_cli.commands.draft_feature_helpers import (
     DRAFT_FEATURE_TABLE_HEADERS,
     base_path,
@@ -22,7 +22,13 @@ from minitest_cli.commands.run_helpers import ensure_uuid, resolve_app, run_api_
 from minitest_cli.models.draft_feature import DraftFeatureResponse, DraftFeatureStatus
 from minitest_cli.utils.output import output, print_error, print_info, print_success, print_table
 
-app = typer.Typer(name="draft", help="Drafts — branches of the app's test suite.")
+app = typer.Typer(
+    name="df",
+    help=(
+        "Low-level branches of the app's test suite (draft features). "
+        "To ask Mini for a change, use `minitest draft`."
+    ),
+)
 draft_feature_show.register(app)
 draft_feature_apply.register(app)
 
@@ -116,6 +122,3 @@ def delete_draft_feature(
         output(feature.model_dump(mode="json", by_alias=True), json_mode=True)
     else:
         print_success(f"Draft abandoned: {feature.id} (status: {feature.status.value})")
-
-
-legacy_app = deprecated_alias(app, old_name="df")

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/commands/draft_feature_apply.py

@@ -1,4 +1,4 @@
-"""`minitest draft apply` — post a changeset file to a branch."""
+"""`minitest df apply` — post a changeset file to a branch."""
 
 from pathlib import Path
 from typing import Annotated

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/commands/draft_feature_conflicts.py

@@ -1,4 +1,4 @@
-"""Rendering for `minitest draft show --view conflicts`.
+"""Rendering for `minitest df show --view conflicts`.
 
 The three sides of a conflict are whole story tuples, so printing them as three
 JSON blobs in a table makes the one thing a resolver needs — which key is in

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/commands/draft_feature_helpers.py

@@ -59,9 +59,7 @@ def handle_response_error(resp: httpx.Response, *, resource: str = "Draft featur
     if resp.status_code == 409:
         detail = extract_detail(resp)
         print_error(detail or f"{resource} changed since it was read.")
-        print_info(
-            "Re-run `draft show --view diff`, rebuild against the mainRev it returns, retry."
-        )
+        print_info("Re-run `df show --view diff`, rebuild against the mainRev it returns, retry.")
         raise typer.Exit(code=EXIT_CONFLICT)
     if resp.status_code >= 400:
         detail = extract_detail(resp)

{minitest_cli-0.36.0 → minitest_cli-0.37.0}/src/minitest_cli/commands/draft_feature_show.py

@@ -1,4 +1,4 @@
-"""`minitest draft show` — read a branch as a diff, as the suite it runs, or as its conflicts."""
+"""`minitest df show` — read a branch as a diff, as the suite it runs, or as its conflicts."""
 
 from enum import StrEnum
 from typing import Annotated