planvortex 0.3.0__tar.gz → 0.4.0__tar.gz

{planvortex-0.3.0 → planvortex-0.4.0}/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this package are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-08-31
+
+An AI plan can now be **archived**, and deleting one finally means what people thought it meant.
+
+The two look alike on a screen and have nothing in common underneath: archiving takes the plan out
+of the listing and touches nothing else, while deleting takes the publications that had not gone out
+with it. Almost every time someone reaches for "remove" they wanted the first one.
+
+Upgrading from `0.3.0` needs no changes and `MIGRATION.md` gains no entry — everything added here is
+additive. **Read the note on `remove()` anyway**: what it deletes changed in the server, so it has
+been happening to your `0.3.0` calls for a while and the docs that shipped with them say otherwise.
+
+### Added
+
+- **`ai_plans.archive()` and `ai_plans.unarchive()`**, in both clients. Archiving is **visibility
+  only**: the plan leaves the listing and moves to the archived one, no publication is touched —
+  anything scheduled keeps publishing — no credits come back, nothing is cancelled. It therefore
+  works in **any state**, `generating` included, and it is undone. On the object it is
+  `archived_date`: a field, **not** a value of `state`, so reading the state to find out whether a
+  plan is archived will never work. Absent means active, which is how every plan created before the
+  field existed comes back.
+- **`archived` on `ai_plans.list()` and `ai_plans.aiterate()`/`iterate()`.** `True` returns the
+  archived plans instead of the active ones, never both at once. A `False` is not sent: the server
+  switches the filter on with the literal `"true"`, so it would be noise — and it would suggest a
+  third mode with both cupboards open that does not exist.
+
+### Changed
+
+- **`ai_plans.remove()` deletes the plan's publications that have not gone out yet**, not only the
+  drafts: if the plan had already been validated, whatever was still scheduled goes too. This is a
+  change **in the server**, so it reached your existing calls the day it shipped — before it, a
+  validated plan you deleted kept publishing by itself the following week. Two states are
+  deliberately left alone: the already published one, because deleting it here would not take it off
+  the network and would only lose its history, and the one being published at that very moment.
+  If you wanted the plan out of the way without losing anything, that is `archive()`.
+
 ## [0.3.0] - 2026-08-31
 
 The AI planner stops being one thing. A plan can now be generated from **your own photos**, from an

{planvortex-0.3.0 → planvortex-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: planvortex
-Version: 0.3.0
+Version: 0.4.0
 Summary: Official Python client for the PlanVortex API
 Project-URL: Homepage, https://planvortex.com/developers
 Project-URL: Documentation, https://taliasoftworks.github.io/PlanVortexPython/

{planvortex-0.3.0 → planvortex-0.4.0}/openapi/planvortex.openapi.json

@@ -1000,7 +1000,7 @@
           "ai_plans"
         ],
         "summary": "List AI publication plans",
-        "description": "Return the organization's AI plans ordered by creation date (desc), paginated. Requires the ai_plans:read permission.\n\n**Cancelled plans are not listed.** Deleting a plan sets it to `cancelled` rather than removing it, and this listing filters those out — so a plan you deleted simply stops appearing, while `GET` by id still returns it.\n\nWithout `limit` the whole list comes back.",
+        "description": "Return the organization's AI plans ordered by creation date (desc), paginated. Requires the ai_plans:read permission.\n\n**Active plans by default, archived ones with `archived=true`** — never both at once. Archiving is visibility only (see `POST .../archive`): the plan leaves this listing and keeps every publication it had.\n\n**Cancelled plans are not listed either.** Deleting a plan sets it to `cancelled` rather than removing it, and this listing filters those out — so a plan you deleted simply stops appearing, while `GET` by id still returns it.\n\nWithout `limit` the whole list comes back.",
         "operationId": "getAiPlans",
         "x-planvortex-identity": [
           "current_user",
@@ -1031,6 +1031,16 @@
             "schema": {
               "type": "integer"
             }
+          },
+          {
+            "name": "archived",
+            "in": "query",
+            "description": "`true` returns the archived plans instead of the active ones. Anything other than the literal string `true` is read as false.",
+            "required": false,
+            "schema": {
+              "type": "boolean",
+              "default": false
+            }
           }
         ],
         "responses": {
@@ -1113,8 +1123,8 @@
         "tags": [
           "ai_plans"
         ],
-        "summary": "Cancel / discard an AI publication plan",
-        "description": "Discard the plan and delete its generated draft publications. AI credits already spent on generation are NOT refunded (same criterion as X: if the provider charged, we charge). Requires the ai_plans:delete permission.",
+        "summary": "Delete an AI publication plan and its pending publications",
+        "description": "Delete the plan **and every publication of it that has not gone out yet**: the generated drafts and, if the plan was already validated, whatever was still scheduled. Two states are deliberately left alone: `sended`, because it is already live on the network and deleting it here would only lose its history while the post stays up, and `publishing`, which the publishing job holds at that very moment.\n\nAI credits already spent on generation are NOT refunded (same criterion as X: if the provider charged, we charge). A plan being generated cannot be deleted (state `generating`, error 2102): wait for the job to finish.\n\nTo keep the plan and its publications and only take it out of the listing, archive it instead (`POST .../archive`). Requires the ai_plans:delete permission.",
         "operationId": "deleteAiPlan",
         "x-planvortex-identity": [
           "current_user",
@@ -1258,6 +1268,106 @@
         }
       }
     },
+    "/clients/{id_client}/organizations/{id_organization}/ai_plans/{id_ai_plan}/archive": {
+      "post": {
+        "tags": [
+          "ai_plans"
+        ],
+        "summary": "Archive an AI publication plan",
+        "description": "Take the plan out of the default listing and move it to the archived one (`GET .../ai_plans?archived=true`). It is **visibility only**: no publication is touched — anything scheduled keeps publishing — no credits are refunded, and nothing is cancelled. It is reversible with `POST .../unarchive` and valid in **any state**, `generating` included, because it does not interrupt the generation job.\n\nArchiving an already archived plan just refreshes `archived_date`. Requires the ai_plans:update permission.",
+        "operationId": "archiveAiPlan",
+        "x-planvortex-identity": [
+          "current_user",
+          "current_app"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/AiPlansidClient"
+          },
+          {
+            "$ref": "#/components/parameters/AiPlansidOrganization"
+          },
+          {
+            "$ref": "#/components/parameters/AiPlansidAiPlan"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful operation. Returns the plan with `archived_date` set.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/AiPlansAiPlanOne"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "The request failed. The body carries the PlanVortex error code in `code`:\n\n| Code | Meaning |\n| --- | --- |\n| `1101` | Invalid organization |\n| `2100` | AI plan doesn't exist. The identifier is invalid or doesn't exist. |\n| `521` | Invalid client. The identifier is invalid or doesn't exist |",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Error"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Unhandled error by the server"
+          }
+        }
+      }
+    },
+    "/clients/{id_client}/organizations/{id_organization}/ai_plans/{id_ai_plan}/unarchive": {
+      "post": {
+        "tags": [
+          "ai_plans"
+        ],
+        "summary": "Unarchive an AI publication plan",
+        "description": "Return the plan to the default listing: `archived_date` is cleared. Unarchiving a plan that was not archived does nothing and answers 200. Requires the ai_plans:update permission.",
+        "operationId": "unarchiveAiPlan",
+        "x-planvortex-identity": [
+          "current_user",
+          "current_app"
+        ],
+        "parameters": [
+          {
+            "$ref": "#/components/parameters/AiPlansidClient"
+          },
+          {
+            "$ref": "#/components/parameters/AiPlansidOrganization"
+          },
+          {
+            "$ref": "#/components/parameters/AiPlansidAiPlan"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful operation. Returns the plan without `archived_date`.",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/AiPlansAiPlanOne"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "The request failed. The body carries the PlanVortex error code in `code`:\n\n| Code | Meaning |\n| --- | --- |\n| `1101` | Invalid organization |\n| `2100` | AI plan doesn't exist. The identifier is invalid or doesn't exist. |\n| `521` | Invalid client. The identifier is invalid or doesn't exist |",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Error"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Unhandled error by the server"
+          }
+        }
+      }
+    },
     "/clients/{id_client}/organizations/{id_organization}/ai_plans/{id_ai_plan}/publications/{id_publication}/regenerate": {
       "post": {
         "tags": [
@@ -9597,6 +9707,11 @@
             ],
             "description": "State machine: pending -> generating -> generated -> validated | failed | cancelled. Poll the plan while state is pending or generating."
           },
+          "archived_date": {
+            "type": "string",
+            "format": "date-time",
+            "description": "When the plan was archived. Absent means it is active, which is how every plan created before archiving existed comes back.\n\nIt is a field of its own and NOT a value of `state` on purpose: `state` is the generation lifecycle and archiving is orthogonal to it — a `validated` plan that already published gets archived just like a `failed` one. Inside the enum you would have to decide which state it returns to when unarchived, and that question has no answer.\n\nArchiving is visibility only: it takes the plan out of the default listing and touches no publication. Anything it had scheduled keeps publishing."
+          },
           "orchestrator_result": {
             "type": "object",
             "description": "Raw plan returned by the orchestrator, kept for audit (before validation/trimming)."

{planvortex-0.3.0 → planvortex-0.4.0}/pyproject.toml

@@ -9,7 +9,7 @@ name = "planvortex"
 # entonces `project.version` desapareceria del pyproject y el paso del workflow de release que
 # compara el tag con la version —que lo lee con `tomllib`— dejaria de encontrarla. Se quedan las dos
 # y las ata `tests/test_packaging.py`, que falla si se separan.
-version = "0.3.0"
+version = "0.4.0"
 description = "Official Python client for the PlanVortex API"
 readme = "README.md"
 requires-python = ">=3.10"

{planvortex-0.3.0 → planvortex-0.4.0}/src/planvortex/_generated/models.py

@@ -2872,6 +2872,14 @@ class AiPlansAiPlan(TypedDict):
     """
     State machine: pending -> generating -> generated -> validated | failed | cancelled. Poll the plan while state is pending or generating.
     """
+    archived_date: NotRequired[str]
+    """
+    When the plan was archived. Absent means it is active, which is how every plan created before archiving existed comes back.
+
+    It is a field of its own and NOT a value of `state` on purpose: `state` is the generation lifecycle and archiving is orthogonal to it — a `validated` plan that already published gets archived just like a `failed` one. Inside the enum you would have to decide which state it returns to when unarchived, and that question has no answer.
+
+    Archiving is visibility only: it takes the plan out of the default listing and touches no publication. Anything it had scheduled keeps publishing.
+    """
     orchestrator_result: NotRequired[dict[str, Any]]
     """
     Raw plan returned by the orchestrator, kept for audit (before validation/trimming).

{planvortex-0.3.0 → planvortex-0.4.0}/src/planvortex/_version.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 import platform
 
-VERSION = "0.3.0"
+VERSION = "0.4.0"
 
 # Sin barra final, y con el `/v1.0.0` dentro: la version de la API es parte de la ruta, no una
 # cabecera, asi que una `base_url` sin ella da 404 en todo.

{planvortex-0.3.0 → planvortex-0.4.0}/src/planvortex/resources/ai_plans.py

@@ -22,7 +22,13 @@ AND WHAT SURPRISES PEOPLE:
   so Monday/Wednesday/Friday with 3 accounts is 9 publications, not 21.
 - **These routes hang off the CLIENT**, not only off the organization: they carry both identifiers.
 - **Deleting is cancelling.** The plan moves to ``cancelled`` and stops appearing in the listing, but
-  :meth:`AsyncAiPlansResource.get` still returns it.
+  :meth:`AsyncAiPlansResource.get` still returns it. What does go for good are its publications that
+  had not gone out yet: the drafts and, if the plan was already validated, whatever was still
+  scheduled.
+- **Archiving is NOT deleting, and it is the action people are usually after.**
+  :meth:`AsyncAiPlansResource.archive` takes the plan out of the listing and touches no publication
+  — anything scheduled keeps publishing — works in any state and can be undone. The archived ones
+  are read with ``list(..., archived=True)``, never next to the active ones.
 
 THE TEMPLATES: WHAT THE PLAN IS GENERATED FROM
 
@@ -67,7 +73,7 @@ from collections.abc import AsyncIterator
 
 from planvortex._core.pagination import Page, PageParams
 from planvortex._shapes import AiPlanRegenerateResult
-from planvortex.resources.base import AsyncResource, require_id
+from planvortex.resources.base import AsyncResource, Query, require_id
 from planvortex.types import AiPlan, AiPlanCreateRequest, AiPlanCreateResult
 
 
@@ -166,17 +172,27 @@ class AsyncAiPlansResource(AsyncResource):
         *,
         limit: int | None = None,
         offset: int | None = None,
+        archived: bool | None = None,
         timeout: float | None = None,
     ) -> Page[AiPlan]:
-        """The organization's plans, from the newest to the oldest.
+        """The organization's ACTIVE plans, from the newest to the oldest.
 
-        **The cancelled ones do not show up**, and here ``publications`` are identifiers, not the
-        whole publications: for that there is :meth:`get`. With no ``limit`` they all come back.
+        **The cancelled ones do not show up** — nor the archived ones, which are asked for with
+        ``archived=True`` — and here ``publications`` are identifiers, not the whole publications:
+        for that there is :meth:`get`. With no ``limit`` they all come back.
+
+        ``archived`` opens the other cupboard, never both at once: archiving moves a plan somewhere
+        else, it does not put a label on it and leave it where it was.
+
+        .. code-block:: python
+
+            activos = await pv.ai_plans.list(client_id, org_id)
+            guardados = await pv.ai_plans.list(client_id, org_id, archived=True)
         """
         pagina: Page[AiPlan] = await self._list(
             self._path(id_client, id_organization),
             "ai_plans",
-            {"limit": limit, "offset": offset},
+            self._list_query(limit, offset, archived),
             timeout=timeout,
         )
         return pagina
@@ -188,6 +204,7 @@ class AsyncAiPlansResource(AsyncResource):
         *,
         limit: int | None = None,
         offset: int | None = None,
+        archived: bool | None = None,
         timeout: float | None = None,
     ) -> AsyncIterator[AiPlan]:
         """The organization's plans, chaining pages."""
@@ -198,6 +215,7 @@ class AsyncAiPlansResource(AsyncResource):
                 id_organization,
                 limit=params.limit,
                 offset=params.offset,
+                archived=archived,
                 timeout=timeout,
             )
 
@@ -274,6 +292,47 @@ class AsyncAiPlansResource(AsyncResource):
         resultado: AiPlanRegenerateResult = await self._post(ruta, {"target": target}, timeout=timeout)
         return resultado
 
+    async def archive(
+        self,
+        id_client: str,
+        id_organization: str,
+        id_ai_plan: str,
+        *,
+        timeout: float | None = None,
+    ) -> AiPlan:
+        """Archive the plan: it leaves the listing and moves to the archived one
+        (``list(..., archived=True)``).
+
+        It is **visibility only**. No publication is touched — anything scheduled keeps publishing —
+        no credits are refunded and nothing is cancelled, so it works in ANY state, ``generating``
+        included: it does not interrupt the job. Undone with :meth:`unarchive`.
+
+        It is what people are after almost every time they think of "removing" a plan: :meth:`remove`
+        takes the publications that have not gone out with it, and this does not.
+        """
+        plan: AiPlan = await self._post_one(
+            f"{self._one_path(id_client, id_organization, id_ai_plan)}/archive",
+            "ai_plan",
+            timeout=timeout,
+        )
+        return plan
+
+    async def unarchive(
+        self,
+        id_client: str,
+        id_organization: str,
+        id_ai_plan: str,
+        *,
+        timeout: float | None = None,
+    ) -> AiPlan:
+        """Put the plan back in the active listing. On a plan that was not archived it does nothing."""
+        plan: AiPlan = await self._post_one(
+            f"{self._one_path(id_client, id_organization, id_ai_plan)}/unarchive",
+            "ai_plan",
+            timeout=timeout,
+        )
+        return plan
+
     async def remove(
         self,
         id_client: str,
@@ -282,11 +341,28 @@ class AsyncAiPlansResource(AsyncResource):
         *,
         timeout: float | None = None,
     ) -> None:
-        """Cancel the plan. **It does not delete it**: it moves to ``cancelled``, disappears from
-        :meth:`list` and :meth:`get` still returns it.
+        """Delete the plan **and its publications that have not gone out yet**: the generated drafts
+        and, if it had already been validated, whatever was still scheduled. The already published
+        ones stay — deleting them here would not take them off the network, it would only lose their
+        history — and neither is the one being published at that very moment touched.
+
+        The plan itself is not wiped: it moves to ``cancelled``, disappears from :meth:`list` and
+        :meth:`get` still returns it. Spent credits are not refunded and a ``generating`` plan cannot
+        be deleted (2102): wait for the job to finish.
+
+        To stop seeing it without losing anything, :meth:`archive`.
         """
         await self._delete(self._one_path(id_client, id_organization, id_ai_plan), timeout=timeout)
 
+    def _list_query(self, limit: int | None, offset: int | None, archived: bool | None) -> Query:
+        return {
+            "limit": limit,
+            "offset": offset,
+            # El servidor enciende el filtro con el literal "true": mandar `archived=false` pediria
+            # lo mismo que no mandar nada, asi que un `False` se omite en vez de viajar como ruido.
+            "archived": True if archived else None,
+        }
+
     def _path(self, id_client: str, id_organization: str) -> str:
         cliente = require_id(id_client, "id_client")
         organizacion = require_id(id_organization, "id_organization")

{planvortex-0.3.0 → planvortex-0.4.0}/src/planvortex/resources_sync/ai_plans.py

@@ -12,7 +12,7 @@ from collections.abc import Iterator
 
 from planvortex._core.pagination import Page, PageParams
 from planvortex._shapes import AiPlanRegenerateResult
-from planvortex.resources_sync.base import Resource, require_id
+from planvortex.resources_sync.base import Query, Resource, require_id
 from planvortex.types import AiPlan, AiPlanCreateRequest, AiPlanCreateResult
 
 
@@ -111,17 +111,27 @@ class AiPlansResource(Resource):
         *,
         limit: int | None = None,
         offset: int | None = None,
+        archived: bool | None = None,
         timeout: float | None = None,
     ) -> Page[AiPlan]:
-        """The organization's plans, from the newest to the oldest.
+        """The organization's ACTIVE plans, from the newest to the oldest.
 
-        **The cancelled ones do not show up**, and here ``publications`` are identifiers, not the
-        whole publications: for that there is :meth:`get`. With no ``limit`` they all come back.
+        **The cancelled ones do not show up** — nor the archived ones, which are asked for with
+        ``archived=True`` — and here ``publications`` are identifiers, not the whole publications:
+        for that there is :meth:`get`. With no ``limit`` they all come back.
+
+        ``archived`` opens the other cupboard, never both at once: archiving moves a plan somewhere
+        else, it does not put a label on it and leave it where it was.
+
+        .. code-block:: python
+
+            activos = pv.ai_plans.list(client_id, org_id)
+            guardados = pv.ai_plans.list(client_id, org_id, archived=True)
         """
         pagina: Page[AiPlan] = self._list(
             self._path(id_client, id_organization),
             "ai_plans",
-            {"limit": limit, "offset": offset},
+            self._list_query(limit, offset, archived),
             timeout=timeout,
         )
         return pagina
@@ -133,6 +143,7 @@ class AiPlansResource(Resource):
         *,
         limit: int | None = None,
         offset: int | None = None,
+        archived: bool | None = None,
         timeout: float | None = None,
     ) -> Iterator[AiPlan]:
         """The organization's plans, chaining pages."""
@@ -143,6 +154,7 @@ class AiPlansResource(Resource):
                 id_organization,
                 limit=params.limit,
                 offset=params.offset,
+                archived=archived,
                 timeout=timeout,
             )
 
@@ -219,6 +231,47 @@ class AiPlansResource(Resource):
         resultado: AiPlanRegenerateResult = self._post(ruta, {"target": target}, timeout=timeout)
         return resultado
 
+    def archive(
+        self,
+        id_client: str,
+        id_organization: str,
+        id_ai_plan: str,
+        *,
+        timeout: float | None = None,
+    ) -> AiPlan:
+        """Archive the plan: it leaves the listing and moves to the archived one
+        (``list(..., archived=True)``).
+
+        It is **visibility only**. No publication is touched — anything scheduled keeps publishing —
+        no credits are refunded and nothing is cancelled, so it works in ANY state, ``generating``
+        included: it does not interrupt the job. Undone with :meth:`unarchive`.
+
+        It is what people are after almost every time they think of "removing" a plan: :meth:`remove`
+        takes the publications that have not gone out with it, and this does not.
+        """
+        plan: AiPlan = self._post_one(
+            f"{self._one_path(id_client, id_organization, id_ai_plan)}/archive",
+            "ai_plan",
+            timeout=timeout,
+        )
+        return plan
+
+    def unarchive(
+        self,
+        id_client: str,
+        id_organization: str,
+        id_ai_plan: str,
+        *,
+        timeout: float | None = None,
+    ) -> AiPlan:
+        """Put the plan back in the active listing. On a plan that was not archived it does nothing."""
+        plan: AiPlan = self._post_one(
+            f"{self._one_path(id_client, id_organization, id_ai_plan)}/unarchive",
+            "ai_plan",
+            timeout=timeout,
+        )
+        return plan
+
     def remove(
         self,
         id_client: str,
@@ -227,11 +280,28 @@ class AiPlansResource(Resource):
         *,
         timeout: float | None = None,
     ) -> None:
-        """Cancel the plan. **It does not delete it**: it moves to ``cancelled``, disappears from
-        :meth:`list` and :meth:`get` still returns it.
+        """Delete the plan **and its publications that have not gone out yet**: the generated drafts
+        and, if it had already been validated, whatever was still scheduled. The already published
+        ones stay — deleting them here would not take them off the network, it would only lose their
+        history — and neither is the one being published at that very moment touched.
+
+        The plan itself is not wiped: it moves to ``cancelled``, disappears from :meth:`list` and
+        :meth:`get` still returns it. Spent credits are not refunded and a ``generating`` plan cannot
+        be deleted (2102): wait for the job to finish.
+
+        To stop seeing it without losing anything, :meth:`archive`.
         """
         self._delete(self._one_path(id_client, id_organization, id_ai_plan), timeout=timeout)
 
+    def _list_query(self, limit: int | None, offset: int | None, archived: bool | None) -> Query:
+        return {
+            "limit": limit,
+            "offset": offset,
+            # El servidor enciende el filtro con el literal "true": mandar `archived=false` pediria
+            # lo mismo que no mandar nada, asi que un `False` se omite en vez de viajar como ruido.
+            "archived": True if archived else None,
+        }
+
     def _path(self, id_client: str, id_organization: str) -> str:
         cliente = require_id(id_client, "id_client")
         organizacion = require_id(id_organization, "id_organization")

{planvortex-0.3.0 → planvortex-0.4.0}/tests/test_ai_plans.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 from pytest_httpx2 import HTTPXMock
 
 from tests.conftest import BASE_URL, ClienteDePrueba
-from tests.contrato import cuerpo, peticiones, ruta, unica
+from tests.contrato import cuerpo, peticiones, query, ruta, unica
 
 PLANES = f"{BASE_URL}/clients/cli1/organizations/org1/ai_plans"
 PLAN = {
@@ -222,3 +222,47 @@ def test_borrar_es_cancelar(cliente: ClienteDePrueba, httpx_mock: HTTPXMock) ->
 
     assert cliente.esperar(cliente.pv.ai_plans.remove("cli1", "org1", "plan1")) is None
     assert unica(httpx_mock).method == "DELETE"
+
+
+def test_archivar_y_desarchivar_van_a_dos_rutas(cliente: ClienteDePrueba, httpx_mock: HTTPXMock) -> None:
+    """Son DOS rutas y no un cuerpo con un booleano: lo que hay que fijar es que cada metodo vaya a
+    la suya, y que el estado del plan no cambie al archivarlo.
+    """
+    archivado = {**PLAN, "state": "validated", "archived_date": "2026-08-31T09:00:00.000Z"}
+    httpx_mock.add_response(url=f"{PLANES}/plan1/archive", method="POST", json={"ai_plan": archivado})
+    httpx_mock.add_response(
+        url=f"{PLANES}/plan1/unarchive", method="POST", json={"ai_plan": {**PLAN, "state": "validated"}}
+    )
+
+    guardado = cliente.esperar(cliente.pv.ai_plans.archive("cli1", "org1", "plan1"))
+    devuelto = cliente.esperar(cliente.pv.ai_plans.unarchive("cli1", "org1", "plan1"))
+
+    assert guardado["archived_date"] == "2026-08-31T09:00:00.000Z"
+    # Ausente, no `None`: es como llega cualquier plan activo, incluidos los anteriores al campo
+    assert "archived_date" not in devuelto
+    # Archivar no toca el ciclo de vida: un plan validado archivado sigue siendo `validated`
+    assert guardado["state"] == "validated"
+    archivar, desarchivar = peticiones(httpx_mock)
+    assert ruta(archivar) == "/clients/cli1/organizations/org1/ai_plans/plan1/archive"
+    assert ruta(desarchivar) == "/clients/cli1/organizations/org1/ai_plans/plan1/unarchive"
+    # POST vacios, como validar y reintentar
+    assert cuerpo(archivar) is None
+    assert cuerpo(desarchivar) is None
+
+
+def test_el_listado_pide_el_otro_armario_solo_cuando_se_le_pide(
+    cliente: ClienteDePrueba, httpx_mock: HTTPXMock
+) -> None:
+    httpx_mock.add_response(url=f"{PLANES}?archived=true", json={"ai_plans": [], "total": 0})
+    httpx_mock.add_response(url=PLANES, json={"ai_plans": [PLAN], "total": 1}, is_reusable=True)
+
+    cliente.esperar(cliente.pv.ai_plans.list("cli1", "org1", archived=True))
+    cliente.esperar(cliente.pv.ai_plans.list("cli1", "org1", archived=False))
+    cliente.esperar(cliente.pv.ai_plans.list("cli1", "org1"))
+
+    archivados, negado, sin_decir = peticiones(httpx_mock)
+    assert query(archivados) == {"archived": ["true"]}
+    # `False` no viaja: el servidor enciende el filtro con el literal "true", asi que mandarlo seria
+    # ruido, y ademas invitaria a creer que hay un tercer modo con los dos armarios a la vez
+    assert "archived" not in query(negado)
+    assert "archived" not in query(sin_decir)

{planvortex-0.3.0 → planvortex-0.4.0}/tests/test_route_coverage.py

@@ -45,10 +45,14 @@ RECURSOS = (
 
 
 def test_no_queda_ninguna_ruta_del_alcance_sin_metodo() -> None:
-    """113 de 113. Si esto falla, el mensaje dice exactamente cual falta."""
+    """115 de 115. Si esto falla, el mensaje dice exactamente cual falta.
+
+    Las dos ultimas son `archive` y `unarchive` de un plan de IA: son DOS rutas y no un cuerpo con
+    un booleano, asi que el alcance crece de dos en dos cuando aparece una pareja de estas.
+    """
     sin_cubrir, _, total = route_coverage.informe()
 
-    assert total == 113, "el alcance ha cambiado de tamano: mira si el spec ha crecido"
+    assert total == 115, "el alcance ha cambiado de tamano: mira si el spec ha crecido"
     assert not sin_cubrir, "rutas del spec que ningun recurso construye:\n" + "\n".join(
         str(operacion) for operacion in sin_cubrir
     )