healthcloud-cli 3.7.0__tar.gz → 3.7.1__tar.gz

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: healthcloud-cli
-Version: 3.7.0
+Version: 3.7.1
 Summary: Command-line interface for the HealthCloud MCP gateway, generated from the shared MCP tool manifest.
 Project-URL: Issues, https://github.com/healthcloudservices/healthcloud-services/issues
 Project-URL: Repository, https://github.com/healthcloudservices/healthcloud-services
@@ -751,10 +751,14 @@ uv run --frozen hc ams departments delete --environment dev --tenant-id TENANT_I
   reports a `validation` refusal that names the department, the tenant that
   received it, and tells you to run `hc ams departments get` — it never claims
   a landed write was a stopped no-op.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams departments get` before
-  retrying. It never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams departments get` before retrying. It never
+  re-sends the write and never re-reads on its own.
 
 Read-only team listing and inspection are also complete and unpaged. The bounded
 projection omits descriptions and creator identities; it includes evaluation-suite
@@ -797,10 +801,14 @@ uv run --frozen hc ams teams delete --environment dev --tenant-id TENANT_ID   --
   `validation` refusal that reports the landed write truthfully: it names the
   team and the tenant that actually received it and points to `hc ams teams
   get` — it never claims a landed write was stopped.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams teams get` before retrying. It
-  never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams teams get` before retrying. It never re-sends
+  the write and never re-reads on its own.
 
 The organization hierarchy is the backend-built department/team/agent tree. The
 CLI preserves its order and nesting without issuing entity reads, joining records,
@@ -862,10 +870,14 @@ uv run --frozen hc ams skills delete --environment dev --tenant-id TENANT_ID --s
   landed write truthfully: it names the skill and the tenant that actually
   received it and points to `hc ams skills get` — it never claims a landed
   write was stopped.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams skills get` before retrying. It
-  never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams skills get` before retrying. It never re-sends
+  the write and never re-reads on its own.
 
 Read-only policy catalog listing and inspection are complete and unpaged. The
 bounded projection includes only policy IDs, names, department IDs, guardrail
@@ -954,10 +966,14 @@ uv run --frozen hc ams policies delete --environment dev --tenant-id TENANT_ID -
   landed write truthfully: it names the policy and the tenant that actually
   received it and points to `hc ams policies get` — it never claims a landed
   write was stopped.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams policies get` before retrying.
-  It never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams policies get` before retrying. It never
+  re-sends the write and never re-reads on its own.
 
 Governed authoring sessions and their messages are first-class commands over the
 VibeCoder session routes. Creating a session and appending a message make no model

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/README.md

@@ -733,10 +733,14 @@ uv run --frozen hc ams departments delete --environment dev --tenant-id TENANT_I
   reports a `validation` refusal that names the department, the tenant that
   received it, and tells you to run `hc ams departments get` — it never claims
   a landed write was a stopped no-op.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams departments get` before
-  retrying. It never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams departments get` before retrying. It never
+  re-sends the write and never re-reads on its own.
 
 Read-only team listing and inspection are also complete and unpaged. The bounded
 projection omits descriptions and creator identities; it includes evaluation-suite
@@ -779,10 +783,14 @@ uv run --frozen hc ams teams delete --environment dev --tenant-id TENANT_ID   --
   `validation` refusal that reports the landed write truthfully: it names the
   team and the tenant that actually received it and points to `hc ams teams
   get` — it never claims a landed write was stopped.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams teams get` before retrying. It
-  never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams teams get` before retrying. It never re-sends
+  the write and never re-reads on its own.
 
 The organization hierarchy is the backend-built department/team/agent tree. The
 CLI preserves its order and nesting without issuing entity reads, joining records,
@@ -844,10 +852,14 @@ uv run --frozen hc ams skills delete --environment dev --tenant-id TENANT_ID --s
   landed write truthfully: it names the skill and the tenant that actually
   received it and points to `hc ams skills get` — it never claims a landed
   write was stopped.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams skills get` before retrying. It
-  never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams skills get` before retrying. It never re-sends
+  the write and never re-reads on its own.
 
 Read-only policy catalog listing and inspection are complete and unpaged. The
 bounded projection includes only policy IDs, names, department IDs, guardrail
@@ -936,10 +948,14 @@ uv run --frozen hc ams policies delete --environment dev --tenant-id TENANT_ID -
   landed write truthfully: it names the policy and the tenant that actually
   received it and points to `hc ams policies get` — it never claims a landed
   write was stopped.
-- If the transport times out or the connection drops mid-write, the write's
-  outcome is unknown: the CLI reports one `transport` error whose message says
-  the outcome is unknown and to check `hc ams policies get` before retrying.
-  It never re-sends the write on its own.
+- If the transport times out, the connection drops mid-write, or the server
+  answers an HTTP 5xx/408 before a readable result, the write's outcome is
+  unknown: the CLI exits 1 with an `unknown` envelope
+  (`verification.saved_state: unknown`, `verification.side_effects:
+  unverified`, `data.mutation_replayed: false`, and
+  `data.reconciliation.status: not_read`) whose message says the outcome is
+  unknown and to check `hc ams policies get` before retrying. It never
+  re-sends the write and never re-reads on its own.
 
 Governed authoring sessions and their messages are first-class commands over the
 VibeCoder session routes. Creating a session and appending a message make no model

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/healthcloud_cli/ams/departments/operations.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from ..context import AmsDependencies
 from ..domain_errors import DomainReadRefused
-from ..results import succeeded
+from ..results import is_unknown_write_status, succeeded, unknown_write
 from ..target import TenantTarget
 from .projections import department_projection
 
@@ -27,6 +27,18 @@ UNKNOWN_OUTCOME = (
     "department's current server state before deciding whether to retry."
 )
 
+UNKNOWN_HTTP_OUTCOME = (
+    "The department write was sent once and its outcome is now unknown: the server answered with an "
+    "error status before a readable result, so the request may have been processed. Run "
+    "`hc ams departments get` to check the department's current server state before deciding whether "
+    "to retry."
+)
+
+UNKNOWN_RECONCILIATION = (
+    "This command did not re-read the department after the uncertain write; run "
+    "`hc ams departments list` before doing anything else."
+)
+
 
 def _department_id(value: str) -> str:
     if not isinstance(value, str) or not value.strip():
@@ -140,11 +152,26 @@ def create_department(
             )
         except HealthCloudNetworkError:
             # Sent once: the request may have landed; the outcome is unknown, never retried here.
-            raise DepartmentWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "departments.create",
+                _target(target),
+                UNKNOWN_OUTCOME,
+                {"department": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _create_not_found(error, parent_department_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                # A 5xx/408 may have committed server-side: report it as unknown, never a retry shape.
+                unknown_write(
+                    "departments.create",
+                    _target(target),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"department": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     # The write has already landed server-side; a mismatching readback must never be
     # reported as a stopped no-op. Name the tenant that actually received it.
@@ -174,11 +201,25 @@ def update_department(
         try:
             department = resource.update(department_id, **fields)
         except HealthCloudNetworkError:
-            raise DepartmentWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "departments.update",
+                _target(target, department_id),
+                UNKNOWN_OUTCOME,
+                {"department": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, department_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "departments.update",
+                    _target(target, department_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"department": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     _identity(department, target, department_id)
     return _write_result("departments.update", target, department_id, {"department": department_projection(department)})
@@ -193,11 +234,25 @@ def _lifecycle(dependencies: AmsDependencies, target: TenantTarget, department_i
         try:
             department = getattr(resource, method)(department_id)
         except HealthCloudNetworkError:
-            raise DepartmentWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                f"departments.{method}",
+                _target(target, department_id),
+                UNKNOWN_OUTCOME,
+                {"department": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, department_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    f"departments.{method}",
+                    _target(target, department_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"department": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     _identity(department, target, department_id)
     return _write_result(
@@ -225,10 +280,24 @@ def delete_department(dependencies: AmsDependencies, target: TenantTarget, depar
         try:
             resource.delete(department_id)
         except HealthCloudNetworkError:
-            raise DepartmentWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "departments.delete",
+                _target(target, department_id),
+                UNKNOWN_OUTCOME,
+                {"deleted": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, department_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "departments.delete",
+                    _target(target, department_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"deleted": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     return _write_result("departments.delete", target, department_id, {"deleted": True})

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/healthcloud_cli/ams/policies/operations.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from ..context import AmsDependencies
 from ..domain_errors import DomainReadRefused
 from ..output import protected_text
-from ..results import succeeded
+from ..results import is_unknown_write_status, succeeded, unknown_write
 from ..target import TenantTarget
 from .projections import policy_projection
 
@@ -28,6 +28,17 @@ UNKNOWN_OUTCOME = (
     "policy's current server state before deciding whether to retry."
 )
 
+UNKNOWN_HTTP_OUTCOME = (
+    "The policy write was sent once and its outcome is now unknown: the server answered with an "
+    "error status before a readable result, so the request may have been processed. Run "
+    "`hc ams policies get` to check the policy's current server state before deciding whether to retry."
+)
+
+UNKNOWN_RECONCILIATION = (
+    "This command did not re-read the policy after the uncertain write; run `hc ams policies list` "
+    "before doing anything else."
+)
+
 
 def _policy_id(value: str) -> str:
     if not isinstance(value, str) or not value.strip():
@@ -195,11 +206,26 @@ def create_policy(
             )
         except HealthCloudNetworkError:
             # Sent once: the request may have landed; the outcome is unknown, never retried here.
-            raise PolicyWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "policies.create",
+                _target(target),
+                UNKNOWN_OUTCOME,
+                {"policy": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _create_not_found(error, department_id) or _conflict(error, None)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                # A 5xx/408 may have committed server-side: report it as unknown, never a retry shape.
+                unknown_write(
+                    "policies.create",
+                    _target(target),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"policy": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     # The write has already landed server-side; a mismatching readback must never be
     # reported as a stopped no-op. Name the tenant that actually received it.
@@ -248,11 +274,25 @@ def update_policy(
         try:
             policy = resource.update(policy_id, **fields)
         except HealthCloudNetworkError:
-            raise PolicyWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "policies.update",
+                _target(target, policy_id),
+                UNKNOWN_OUTCOME,
+                {"policy": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, policy_id) or _conflict(error, policy_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "policies.update",
+                    _target(target, policy_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"policy": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     _identity(policy, target, policy_id)
     return _write_result("policies.update", target, policy_id, {"policy": policy_projection(policy)})
@@ -270,11 +310,25 @@ def set_policy_active(
         try:
             policy = resource.update(policy_id, active=active)
         except HealthCloudNetworkError:
-            raise PolicyWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                operation,
+                _target(target, policy_id),
+                UNKNOWN_OUTCOME,
+                {"policy": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, policy_id) or _conflict(error, policy_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    operation,
+                    _target(target, policy_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"policy": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     _identity(policy, target, policy_id)
     if policy.active is not active:
@@ -296,10 +350,24 @@ def delete_policy(dependencies: AmsDependencies, target: TenantTarget, policy_id
         try:
             resource.delete(policy_id)
         except HealthCloudNetworkError:
-            raise PolicyWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "policies.delete",
+                _target(target, policy_id),
+                UNKNOWN_OUTCOME,
+                {"deleted": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _in_use(error, policy_id) or _not_found(error, policy_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "policies.delete",
+                    _target(target, policy_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"deleted": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     return _write_result("policies.delete", target, policy_id, {"deleted": True})

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/healthcloud_cli/ams/results.py

@@ -2,6 +2,10 @@
 
 from __future__ import annotations
 
+from typing import NoReturn
+
+from .domain_errors import DomainOutcomeUnknown
+
 VERIFICATION_NOT_APPLICABLE = {
     "saved_state": "not_applicable",
     "side_effects": "not_applicable",
@@ -58,6 +62,55 @@ def unknown(
     return envelope
 
 
+def is_unknown_write_status(status: object) -> bool:
+    """True when an HTTP status leaves a sent mutation's outcome unknown.
+
+    A 5xx (gateway or server error) and a 408 may both mean the server processed
+    the request before the answer was lost, so the write may have committed.
+    429 is deliberately excluded: the server said it did not process the request.
+    """
+
+    return status == 408 or (isinstance(status, int) and 500 <= status < 600)
+
+
+def unknown_write(
+    operation: str,
+    target: dict,
+    message: str,
+    data: dict,
+    *,
+    reconciliation_detail: str,
+) -> NoReturn:
+    """Raise the one unknown-outcome report for a sent catalog mutation.
+
+    The write was sent exactly once and its outcome cannot be known (the transport
+    failed or the server answered 5xx/408 before a readable result), so the
+    envelope says the write may have landed and carries ``mutation_replayed:
+    false`` plus a ``not_read`` reconciliation: this command never re-sends and
+    never re-reads on its own. It is raised (never returned), so the command exits
+    nonzero and the outcome is never mistaken for success.
+    """
+
+    envelope = unknown(
+        operation,
+        target,
+        "transport",
+        message,
+        {
+            **data,
+            "mutation_replayed": False,
+            "reconciliation": {"status": "not_read", "detail": reconciliation_detail},
+        },
+        read_only=False,
+    )
+    envelope["verification"] = {
+        "saved_state": "unknown",
+        "side_effects": "unverified",
+        "runtime": "unverified",
+    }
+    raise DomainOutcomeUnknown("transport", message, envelope)
+
+
 def failed(operation: str, target: dict, category: str, message: str, *, read_only: bool = False) -> dict:
     envelope = {
         "schema_version": 1,

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/healthcloud_cli/ams/skills/operations.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from ..context import AmsDependencies
 from ..domain_errors import DomainReadRefused
-from ..results import succeeded
+from ..results import is_unknown_write_status, succeeded, unknown_write
 from ..target import TenantTarget
 from .projections import skill_projection
 
@@ -27,6 +27,17 @@ UNKNOWN_OUTCOME = (
     "skill's current server state before deciding whether to retry."
 )
 
+UNKNOWN_HTTP_OUTCOME = (
+    "The skill write was sent once and its outcome is now unknown: the server answered with an "
+    "error status before a readable result, so the request may have been processed. Run "
+    "`hc ams skills get` to check the skill's current server state before deciding whether to retry."
+)
+
+UNKNOWN_RECONCILIATION = (
+    "This command did not re-read the skill after the uncertain write; run `hc ams skills list` "
+    "before doing anything else."
+)
+
 
 def _skill_id(value: str) -> str:
     if not isinstance(value, str) or not value.strip():
@@ -140,7 +151,13 @@ def create_skill(
             )
         except HealthCloudNetworkError:
             # Sent once: the request may have landed; the outcome is unknown, never retried here.
-            raise SkillWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "skills.create",
+                _target(target),
+                UNKNOWN_OUTCOME,
+                {"skill": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             # The server does not validate tool references (a 404 is a generic missing
             # referenced record, never a body to echo).
@@ -150,6 +167,15 @@ def create_skill(
                     "A record referenced by the create (for example a tool) was not found in "
                     "this tenant; refused without changes.",
                 ) from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                # A 5xx/408 may have committed server-side: report it as unknown, never a retry shape.
+                unknown_write(
+                    "skills.create",
+                    _target(target),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"skill": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     if skill.tenant_id != target.tenant_id:
         # The write has already landed server-side; report it truthfully, never as a stopped no-op.
@@ -172,11 +198,25 @@ def update_skill(dependencies: AmsDependencies, target: TenantTarget, skill_id:
         try:
             skill = resource.update(skill_id, **fields)
         except HealthCloudNetworkError:
-            raise SkillWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "skills.update",
+                _target(target, skill_id),
+                UNKNOWN_OUTCOME,
+                {"skill": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, skill_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "skills.update",
+                    _target(target, skill_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"skill": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     _identity(skill, target, skill_id)
     return _write_result("skills.update", target, skill_id, {"skill": skill_projection(skill)})
@@ -192,10 +232,24 @@ def delete_skill(dependencies: AmsDependencies, target: TenantTarget, skill_id:
         try:
             resource.delete(skill_id)
         except HealthCloudNetworkError:
-            raise SkillWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "skills.delete",
+                _target(target, skill_id),
+                UNKNOWN_OUTCOME,
+                {"deleted": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _referenced_by_agents(error, skill_id) or _not_found(error, skill_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "skills.delete",
+                    _target(target, skill_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"deleted": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     return _write_result("skills.delete", target, skill_id, {"deleted": True})

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/healthcloud_cli/ams/teams/operations.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from ..context import AmsDependencies
 from ..domain_errors import DomainReadRefused
-from ..results import succeeded
+from ..results import is_unknown_write_status, succeeded, unknown_write
 from ..target import TenantTarget
 from .projections import team_projection
 
@@ -27,6 +27,17 @@ UNKNOWN_OUTCOME = (
     "team's current server state before deciding whether to retry."
 )
 
+UNKNOWN_HTTP_OUTCOME = (
+    "The team write was sent once and its outcome is now unknown: the server answered with an "
+    "error status before a readable result, so the request may have been processed. Run "
+    "`hc ams teams get` to check the team's current server state before deciding whether to retry."
+)
+
+UNKNOWN_RECONCILIATION = (
+    "This command did not re-read the team after the uncertain write; run `hc ams teams list` "
+    "before doing anything else."
+)
+
 
 def _team_id(value: str) -> str:
     if not isinstance(value, str) or not value.strip():
@@ -142,7 +153,13 @@ def create_team(
             )
         except HealthCloudNetworkError:
             # Sent once: the request may have landed; the outcome is unknown, never retried here.
-            raise TeamWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "teams.create",
+                _target(target),
+                UNKNOWN_OUTCOME,
+                {"team": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             # A create 404 means the referenced department is missing (department_id is required).
             if getattr(error, "status_code", None) == 404:
@@ -150,6 +167,15 @@ def create_team(
                     "not_found",
                     f"Department '{department_id}' was not found in this tenant; refused without changes.",
                 ) from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                # A 5xx/408 may have committed server-side: report it as unknown, never a retry shape.
+                unknown_write(
+                    "teams.create",
+                    _target(target),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"team": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     # The write has already landed server-side; a mismatching readback must never be
     # reported as a stopped no-op. Name the tenant that actually received it.
@@ -179,11 +205,25 @@ def update_team(
         try:
             team = resource.update(team_id, **fields)
         except HealthCloudNetworkError:
-            raise TeamWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "teams.update",
+                _target(target, team_id),
+                UNKNOWN_OUTCOME,
+                {"team": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _not_found(error, team_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "teams.update",
+                    _target(target, team_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"team": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     _identity(team, target, team_id)
     return _write_result("teams.update", target, team_id, {"team": team_projection(team)})
@@ -199,10 +239,24 @@ def delete_team(dependencies: AmsDependencies, target: TenantTarget, team_id: st
         try:
             resource.delete(team_id)
         except HealthCloudNetworkError:
-            raise TeamWriteRefused("transport", UNKNOWN_OUTCOME) from None
+            unknown_write(
+                "teams.delete",
+                _target(target, team_id),
+                UNKNOWN_OUTCOME,
+                {"deleted": None},
+                reconciliation_detail=UNKNOWN_RECONCILIATION,
+            )
         except HealthCloudHTTPError as error:
             refusal = _referenced_by_agents(error, team_id) or _not_found(error, team_id)
             if refusal is not None:
                 raise refusal from error
+            if is_unknown_write_status(getattr(error, "status_code", None)):
+                unknown_write(
+                    "teams.delete",
+                    _target(target, team_id),
+                    UNKNOWN_HTTP_OUTCOME,
+                    {"deleted": None},
+                    reconciliation_detail=UNKNOWN_RECONCILIATION,
+                )
             raise
     return _write_result("teams.delete", target, team_id, {"deleted": True})

{healthcloud_cli-3.7.0 → healthcloud_cli-3.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "healthcloud-cli"
-version = "3.7.0"
+version = "3.7.1"
 description = "Command-line interface for the HealthCloud MCP gateway, generated from the shared MCP tool manifest."
 readme = "README.md"
 requires-python = ">=3.14"